+Tue Aug 18 00:29:13 1998 Lars Hamann <lars@gtk.org>
+
+ * gtk/gtkclist.h:
+ (struct _GtkCListClass): new class methods:
+ (sort_list) (insert_row) (remove_row) (set_cell_contents)
+
+ * gtk/gtkclist.c :
+ (cell_empty) (cell_set_text) (cell_set_pixmap) (cell_set_pixtext):
+ removed and replaced by (set_cell_contents)
+ (set_cell_contents): function for class method set_cell_contents
+ (real_insert_row): function for class method insert_row
+ (real_remoce_row): function for class method remove_row
+ (real_sort_list): function for class method sort_list
+ (default_compare): fix to avoid problems with cell types != CELL_TEXT
+
+ * gtk/gtkctree.h :
+ (gtk_ctree_export_to_gnode): new function to export a ctree as gnode
+ (gtk_ctree_node_is_visible): new function to return visibility state
+ of a node
+ (gtk_ctree_show_stub): new function to set visibility of root stub
+
+ renamed functions :
+ (gtk_ctree_insert) -> (gtk_ctree_insert_node)
+ (gtk_ctree_remove) -> (gtk_ctree_remove_node)
+ (gtk_ctree_find_glist_ptr) -> (gtk_ctree_find_node_ptr)
+ (gtk_ctree_set_text) -> (gtk_ctree_node_set_text)
+ (gtk_ctree_set_pixmap) -> (gtk_ctree_node_set_pixmap)
+ (gtk_ctree_set_pixtext) -> (gtk_ctree_node_set_pixtext)
+ (gtk_ctree_set_shift) -> (gtk_ctree_node_set_shift)
+ (gtk_ctree_get_cell_type) -> (gtk_ctree_node_get_cell_type)
+ (gtk_ctree_get_text) -> (gtk_ctree_node_get_text)
+ (gtk_ctree_get_pixmap) -> (gtk_ctree_node_get_pixmap)
+ (gtk_ctree_get_pixtext) -> (gtk_ctree_node_get_pixtext)
+ (gtk_ctree_set_foreground) -> (gtk_ctree_node_set_foreground)
+ (gtk_ctree_set_background) -> (gtk_ctree_node_set_background)
+ (gtk_ctree_set_row_data) -> (gtk_ctree_node_set_row_data)
+ (gtk_ctree_set_row_data_full) -> (gtk_ctree_node_set_row_data_full)
+ (gtk_ctree_get_row_data) -> (gtk_ctree_node_get_row_data)
+ (gtk_ctree_moveto) -> (gtk_ctree_node_moveto)
+ (gtk_ctree_sort) -> (gtk_ctree_sort_node)
+ (gtk_ctree_is_visibe) -> (gtk_ctree_is_viewable)
+
+ * gtk/gtkctree.c :
+ (cell_empty) (cell_set_text) (cell_set_pixmap) (cell_set_pixtext):
+ removed and replaced by (set_cell_contents)
+ (set_cell_contents): function for class method set_cell_contents
+ (real_insert_row): function for class method insert_row
+ (real_remoce_row): function for class method remove_row
+ (real_sort_list): function for class method sort_list
+ (default_compare): removed. CTree now also compares two GtkCTreeRows
+ instead of two GtkCTreeNodes.
+ (gtk_ctree_unlink): call gtk_ctree_collapse if parent is empty after
+ unlinking the node
+ (real_tree_expand) (real_tree_collapse): fix for refcounting of
+ node pixmaps
+ (set_node_info): call gtk_ctree_node_set_pixtext instead of
+ manipulating the row itself
+
+ * gtk/testgtk.c: use renamed functions of GtkCTree.
+ new sample to show gtk_ctree_export_to_gnode and gtk_ctree_insert_gnode
+ at work.
+
Mon Aug 17 15:31:38 1998 Tim Janik <timj@gtk.org>
* gtk/gtkmain.c: removed gtk_input_add_interp.
+Tue Aug 18 00:29:13 1998 Lars Hamann <lars@gtk.org>
+
+ * gtk/gtkclist.h:
+ (struct _GtkCListClass): new class methods:
+ (sort_list) (insert_row) (remove_row) (set_cell_contents)
+
+ * gtk/gtkclist.c :
+ (cell_empty) (cell_set_text) (cell_set_pixmap) (cell_set_pixtext):
+ removed and replaced by (set_cell_contents)
+ (set_cell_contents): function for class method set_cell_contents
+ (real_insert_row): function for class method insert_row
+ (real_remoce_row): function for class method remove_row
+ (real_sort_list): function for class method sort_list
+ (default_compare): fix to avoid problems with cell types != CELL_TEXT
+
+ * gtk/gtkctree.h :
+ (gtk_ctree_export_to_gnode): new function to export a ctree as gnode
+ (gtk_ctree_node_is_visible): new function to return visibility state
+ of a node
+ (gtk_ctree_show_stub): new function to set visibility of root stub
+
+ renamed functions :
+ (gtk_ctree_insert) -> (gtk_ctree_insert_node)
+ (gtk_ctree_remove) -> (gtk_ctree_remove_node)
+ (gtk_ctree_find_glist_ptr) -> (gtk_ctree_find_node_ptr)
+ (gtk_ctree_set_text) -> (gtk_ctree_node_set_text)
+ (gtk_ctree_set_pixmap) -> (gtk_ctree_node_set_pixmap)
+ (gtk_ctree_set_pixtext) -> (gtk_ctree_node_set_pixtext)
+ (gtk_ctree_set_shift) -> (gtk_ctree_node_set_shift)
+ (gtk_ctree_get_cell_type) -> (gtk_ctree_node_get_cell_type)
+ (gtk_ctree_get_text) -> (gtk_ctree_node_get_text)
+ (gtk_ctree_get_pixmap) -> (gtk_ctree_node_get_pixmap)
+ (gtk_ctree_get_pixtext) -> (gtk_ctree_node_get_pixtext)
+ (gtk_ctree_set_foreground) -> (gtk_ctree_node_set_foreground)
+ (gtk_ctree_set_background) -> (gtk_ctree_node_set_background)
+ (gtk_ctree_set_row_data) -> (gtk_ctree_node_set_row_data)
+ (gtk_ctree_set_row_data_full) -> (gtk_ctree_node_set_row_data_full)
+ (gtk_ctree_get_row_data) -> (gtk_ctree_node_get_row_data)
+ (gtk_ctree_moveto) -> (gtk_ctree_node_moveto)
+ (gtk_ctree_sort) -> (gtk_ctree_sort_node)
+ (gtk_ctree_is_visibe) -> (gtk_ctree_is_viewable)
+
+ * gtk/gtkctree.c :
+ (cell_empty) (cell_set_text) (cell_set_pixmap) (cell_set_pixtext):
+ removed and replaced by (set_cell_contents)
+ (set_cell_contents): function for class method set_cell_contents
+ (real_insert_row): function for class method insert_row
+ (real_remoce_row): function for class method remove_row
+ (real_sort_list): function for class method sort_list
+ (default_compare): removed. CTree now also compares two GtkCTreeRows
+ instead of two GtkCTreeNodes.
+ (gtk_ctree_unlink): call gtk_ctree_collapse if parent is empty after
+ unlinking the node
+ (real_tree_expand) (real_tree_collapse): fix for refcounting of
+ node pixmaps
+ (set_node_info): call gtk_ctree_node_set_pixtext instead of
+ manipulating the row itself
+
+ * gtk/testgtk.c: use renamed functions of GtkCTree.
+ new sample to show gtk_ctree_export_to_gnode and gtk_ctree_insert_gnode
+ at work.
+
Mon Aug 17 15:31:38 1998 Tim Janik <timj@gtk.org>
* gtk/gtkmain.c: removed gtk_input_add_interp.
+Tue Aug 18 00:29:13 1998 Lars Hamann <lars@gtk.org>
+
+ * gtk/gtkclist.h:
+ (struct _GtkCListClass): new class methods:
+ (sort_list) (insert_row) (remove_row) (set_cell_contents)
+
+ * gtk/gtkclist.c :
+ (cell_empty) (cell_set_text) (cell_set_pixmap) (cell_set_pixtext):
+ removed and replaced by (set_cell_contents)
+ (set_cell_contents): function for class method set_cell_contents
+ (real_insert_row): function for class method insert_row
+ (real_remoce_row): function for class method remove_row
+ (real_sort_list): function for class method sort_list
+ (default_compare): fix to avoid problems with cell types != CELL_TEXT
+
+ * gtk/gtkctree.h :
+ (gtk_ctree_export_to_gnode): new function to export a ctree as gnode
+ (gtk_ctree_node_is_visible): new function to return visibility state
+ of a node
+ (gtk_ctree_show_stub): new function to set visibility of root stub
+
+ renamed functions :
+ (gtk_ctree_insert) -> (gtk_ctree_insert_node)
+ (gtk_ctree_remove) -> (gtk_ctree_remove_node)
+ (gtk_ctree_find_glist_ptr) -> (gtk_ctree_find_node_ptr)
+ (gtk_ctree_set_text) -> (gtk_ctree_node_set_text)
+ (gtk_ctree_set_pixmap) -> (gtk_ctree_node_set_pixmap)
+ (gtk_ctree_set_pixtext) -> (gtk_ctree_node_set_pixtext)
+ (gtk_ctree_set_shift) -> (gtk_ctree_node_set_shift)
+ (gtk_ctree_get_cell_type) -> (gtk_ctree_node_get_cell_type)
+ (gtk_ctree_get_text) -> (gtk_ctree_node_get_text)
+ (gtk_ctree_get_pixmap) -> (gtk_ctree_node_get_pixmap)
+ (gtk_ctree_get_pixtext) -> (gtk_ctree_node_get_pixtext)
+ (gtk_ctree_set_foreground) -> (gtk_ctree_node_set_foreground)
+ (gtk_ctree_set_background) -> (gtk_ctree_node_set_background)
+ (gtk_ctree_set_row_data) -> (gtk_ctree_node_set_row_data)
+ (gtk_ctree_set_row_data_full) -> (gtk_ctree_node_set_row_data_full)
+ (gtk_ctree_get_row_data) -> (gtk_ctree_node_get_row_data)
+ (gtk_ctree_moveto) -> (gtk_ctree_node_moveto)
+ (gtk_ctree_sort) -> (gtk_ctree_sort_node)
+ (gtk_ctree_is_visibe) -> (gtk_ctree_is_viewable)
+
+ * gtk/gtkctree.c :
+ (cell_empty) (cell_set_text) (cell_set_pixmap) (cell_set_pixtext):
+ removed and replaced by (set_cell_contents)
+ (set_cell_contents): function for class method set_cell_contents
+ (real_insert_row): function for class method insert_row
+ (real_remoce_row): function for class method remove_row
+ (real_sort_list): function for class method sort_list
+ (default_compare): removed. CTree now also compares two GtkCTreeRows
+ instead of two GtkCTreeNodes.
+ (gtk_ctree_unlink): call gtk_ctree_collapse if parent is empty after
+ unlinking the node
+ (real_tree_expand) (real_tree_collapse): fix for refcounting of
+ node pixmaps
+ (set_node_info): call gtk_ctree_node_set_pixtext instead of
+ manipulating the row itself
+
+ * gtk/testgtk.c: use renamed functions of GtkCTree.
+ new sample to show gtk_ctree_export_to_gnode and gtk_ctree_insert_gnode
+ at work.
+
Mon Aug 17 15:31:38 1998 Tim Janik <timj@gtk.org>
* gtk/gtkmain.c: removed gtk_input_add_interp.
+Tue Aug 18 00:29:13 1998 Lars Hamann <lars@gtk.org>
+
+ * gtk/gtkclist.h:
+ (struct _GtkCListClass): new class methods:
+ (sort_list) (insert_row) (remove_row) (set_cell_contents)
+
+ * gtk/gtkclist.c :
+ (cell_empty) (cell_set_text) (cell_set_pixmap) (cell_set_pixtext):
+ removed and replaced by (set_cell_contents)
+ (set_cell_contents): function for class method set_cell_contents
+ (real_insert_row): function for class method insert_row
+ (real_remoce_row): function for class method remove_row
+ (real_sort_list): function for class method sort_list
+ (default_compare): fix to avoid problems with cell types != CELL_TEXT
+
+ * gtk/gtkctree.h :
+ (gtk_ctree_export_to_gnode): new function to export a ctree as gnode
+ (gtk_ctree_node_is_visible): new function to return visibility state
+ of a node
+ (gtk_ctree_show_stub): new function to set visibility of root stub
+
+ renamed functions :
+ (gtk_ctree_insert) -> (gtk_ctree_insert_node)
+ (gtk_ctree_remove) -> (gtk_ctree_remove_node)
+ (gtk_ctree_find_glist_ptr) -> (gtk_ctree_find_node_ptr)
+ (gtk_ctree_set_text) -> (gtk_ctree_node_set_text)
+ (gtk_ctree_set_pixmap) -> (gtk_ctree_node_set_pixmap)
+ (gtk_ctree_set_pixtext) -> (gtk_ctree_node_set_pixtext)
+ (gtk_ctree_set_shift) -> (gtk_ctree_node_set_shift)
+ (gtk_ctree_get_cell_type) -> (gtk_ctree_node_get_cell_type)
+ (gtk_ctree_get_text) -> (gtk_ctree_node_get_text)
+ (gtk_ctree_get_pixmap) -> (gtk_ctree_node_get_pixmap)
+ (gtk_ctree_get_pixtext) -> (gtk_ctree_node_get_pixtext)
+ (gtk_ctree_set_foreground) -> (gtk_ctree_node_set_foreground)
+ (gtk_ctree_set_background) -> (gtk_ctree_node_set_background)
+ (gtk_ctree_set_row_data) -> (gtk_ctree_node_set_row_data)
+ (gtk_ctree_set_row_data_full) -> (gtk_ctree_node_set_row_data_full)
+ (gtk_ctree_get_row_data) -> (gtk_ctree_node_get_row_data)
+ (gtk_ctree_moveto) -> (gtk_ctree_node_moveto)
+ (gtk_ctree_sort) -> (gtk_ctree_sort_node)
+ (gtk_ctree_is_visibe) -> (gtk_ctree_is_viewable)
+
+ * gtk/gtkctree.c :
+ (cell_empty) (cell_set_text) (cell_set_pixmap) (cell_set_pixtext):
+ removed and replaced by (set_cell_contents)
+ (set_cell_contents): function for class method set_cell_contents
+ (real_insert_row): function for class method insert_row
+ (real_remoce_row): function for class method remove_row
+ (real_sort_list): function for class method sort_list
+ (default_compare): removed. CTree now also compares two GtkCTreeRows
+ instead of two GtkCTreeNodes.
+ (gtk_ctree_unlink): call gtk_ctree_collapse if parent is empty after
+ unlinking the node
+ (real_tree_expand) (real_tree_collapse): fix for refcounting of
+ node pixmaps
+ (set_node_info): call gtk_ctree_node_set_pixtext instead of
+ manipulating the row itself
+
+ * gtk/testgtk.c: use renamed functions of GtkCTree.
+ new sample to show gtk_ctree_export_to_gnode and gtk_ctree_insert_gnode
+ at work.
+
Mon Aug 17 15:31:38 1998 Tim Janik <timj@gtk.org>
* gtk/gtkmain.c: removed gtk_input_add_interp.
+Tue Aug 18 00:29:13 1998 Lars Hamann <lars@gtk.org>
+
+ * gtk/gtkclist.h:
+ (struct _GtkCListClass): new class methods:
+ (sort_list) (insert_row) (remove_row) (set_cell_contents)
+
+ * gtk/gtkclist.c :
+ (cell_empty) (cell_set_text) (cell_set_pixmap) (cell_set_pixtext):
+ removed and replaced by (set_cell_contents)
+ (set_cell_contents): function for class method set_cell_contents
+ (real_insert_row): function for class method insert_row
+ (real_remoce_row): function for class method remove_row
+ (real_sort_list): function for class method sort_list
+ (default_compare): fix to avoid problems with cell types != CELL_TEXT
+
+ * gtk/gtkctree.h :
+ (gtk_ctree_export_to_gnode): new function to export a ctree as gnode
+ (gtk_ctree_node_is_visible): new function to return visibility state
+ of a node
+ (gtk_ctree_show_stub): new function to set visibility of root stub
+
+ renamed functions :
+ (gtk_ctree_insert) -> (gtk_ctree_insert_node)
+ (gtk_ctree_remove) -> (gtk_ctree_remove_node)
+ (gtk_ctree_find_glist_ptr) -> (gtk_ctree_find_node_ptr)
+ (gtk_ctree_set_text) -> (gtk_ctree_node_set_text)
+ (gtk_ctree_set_pixmap) -> (gtk_ctree_node_set_pixmap)
+ (gtk_ctree_set_pixtext) -> (gtk_ctree_node_set_pixtext)
+ (gtk_ctree_set_shift) -> (gtk_ctree_node_set_shift)
+ (gtk_ctree_get_cell_type) -> (gtk_ctree_node_get_cell_type)
+ (gtk_ctree_get_text) -> (gtk_ctree_node_get_text)
+ (gtk_ctree_get_pixmap) -> (gtk_ctree_node_get_pixmap)
+ (gtk_ctree_get_pixtext) -> (gtk_ctree_node_get_pixtext)
+ (gtk_ctree_set_foreground) -> (gtk_ctree_node_set_foreground)
+ (gtk_ctree_set_background) -> (gtk_ctree_node_set_background)
+ (gtk_ctree_set_row_data) -> (gtk_ctree_node_set_row_data)
+ (gtk_ctree_set_row_data_full) -> (gtk_ctree_node_set_row_data_full)
+ (gtk_ctree_get_row_data) -> (gtk_ctree_node_get_row_data)
+ (gtk_ctree_moveto) -> (gtk_ctree_node_moveto)
+ (gtk_ctree_sort) -> (gtk_ctree_sort_node)
+ (gtk_ctree_is_visibe) -> (gtk_ctree_is_viewable)
+
+ * gtk/gtkctree.c :
+ (cell_empty) (cell_set_text) (cell_set_pixmap) (cell_set_pixtext):
+ removed and replaced by (set_cell_contents)
+ (set_cell_contents): function for class method set_cell_contents
+ (real_insert_row): function for class method insert_row
+ (real_remoce_row): function for class method remove_row
+ (real_sort_list): function for class method sort_list
+ (default_compare): removed. CTree now also compares two GtkCTreeRows
+ instead of two GtkCTreeNodes.
+ (gtk_ctree_unlink): call gtk_ctree_collapse if parent is empty after
+ unlinking the node
+ (real_tree_expand) (real_tree_collapse): fix for refcounting of
+ node pixmaps
+ (set_node_info): call gtk_ctree_node_set_pixtext instead of
+ manipulating the row itself
+
+ * gtk/testgtk.c: use renamed functions of GtkCTree.
+ new sample to show gtk_ctree_export_to_gnode and gtk_ctree_insert_gnode
+ at work.
+
Mon Aug 17 15:31:38 1998 Tim Janik <timj@gtk.org>
* gtk/gtkmain.c: removed gtk_input_add_interp.
+Tue Aug 18 00:29:13 1998 Lars Hamann <lars@gtk.org>
+
+ * gtk/gtkclist.h:
+ (struct _GtkCListClass): new class methods:
+ (sort_list) (insert_row) (remove_row) (set_cell_contents)
+
+ * gtk/gtkclist.c :
+ (cell_empty) (cell_set_text) (cell_set_pixmap) (cell_set_pixtext):
+ removed and replaced by (set_cell_contents)
+ (set_cell_contents): function for class method set_cell_contents
+ (real_insert_row): function for class method insert_row
+ (real_remoce_row): function for class method remove_row
+ (real_sort_list): function for class method sort_list
+ (default_compare): fix to avoid problems with cell types != CELL_TEXT
+
+ * gtk/gtkctree.h :
+ (gtk_ctree_export_to_gnode): new function to export a ctree as gnode
+ (gtk_ctree_node_is_visible): new function to return visibility state
+ of a node
+ (gtk_ctree_show_stub): new function to set visibility of root stub
+
+ renamed functions :
+ (gtk_ctree_insert) -> (gtk_ctree_insert_node)
+ (gtk_ctree_remove) -> (gtk_ctree_remove_node)
+ (gtk_ctree_find_glist_ptr) -> (gtk_ctree_find_node_ptr)
+ (gtk_ctree_set_text) -> (gtk_ctree_node_set_text)
+ (gtk_ctree_set_pixmap) -> (gtk_ctree_node_set_pixmap)
+ (gtk_ctree_set_pixtext) -> (gtk_ctree_node_set_pixtext)
+ (gtk_ctree_set_shift) -> (gtk_ctree_node_set_shift)
+ (gtk_ctree_get_cell_type) -> (gtk_ctree_node_get_cell_type)
+ (gtk_ctree_get_text) -> (gtk_ctree_node_get_text)
+ (gtk_ctree_get_pixmap) -> (gtk_ctree_node_get_pixmap)
+ (gtk_ctree_get_pixtext) -> (gtk_ctree_node_get_pixtext)
+ (gtk_ctree_set_foreground) -> (gtk_ctree_node_set_foreground)
+ (gtk_ctree_set_background) -> (gtk_ctree_node_set_background)
+ (gtk_ctree_set_row_data) -> (gtk_ctree_node_set_row_data)
+ (gtk_ctree_set_row_data_full) -> (gtk_ctree_node_set_row_data_full)
+ (gtk_ctree_get_row_data) -> (gtk_ctree_node_get_row_data)
+ (gtk_ctree_moveto) -> (gtk_ctree_node_moveto)
+ (gtk_ctree_sort) -> (gtk_ctree_sort_node)
+ (gtk_ctree_is_visibe) -> (gtk_ctree_is_viewable)
+
+ * gtk/gtkctree.c :
+ (cell_empty) (cell_set_text) (cell_set_pixmap) (cell_set_pixtext):
+ removed and replaced by (set_cell_contents)
+ (set_cell_contents): function for class method set_cell_contents
+ (real_insert_row): function for class method insert_row
+ (real_remoce_row): function for class method remove_row
+ (real_sort_list): function for class method sort_list
+ (default_compare): removed. CTree now also compares two GtkCTreeRows
+ instead of two GtkCTreeNodes.
+ (gtk_ctree_unlink): call gtk_ctree_collapse if parent is empty after
+ unlinking the node
+ (real_tree_expand) (real_tree_collapse): fix for refcounting of
+ node pixmaps
+ (set_node_info): call gtk_ctree_node_set_pixtext instead of
+ manipulating the row itself
+
+ * gtk/testgtk.c: use renamed functions of GtkCTree.
+ new sample to show gtk_ctree_export_to_gnode and gtk_ctree_insert_gnode
+ at work.
+
Mon Aug 17 15:31:38 1998 Tim Janik <timj@gtk.org>
* gtk/gtkmain.c: removed gtk_input_add_interp.
+Tue Aug 18 00:29:13 1998 Lars Hamann <lars@gtk.org>
+
+ * gtk/gtkclist.h:
+ (struct _GtkCListClass): new class methods:
+ (sort_list) (insert_row) (remove_row) (set_cell_contents)
+
+ * gtk/gtkclist.c :
+ (cell_empty) (cell_set_text) (cell_set_pixmap) (cell_set_pixtext):
+ removed and replaced by (set_cell_contents)
+ (set_cell_contents): function for class method set_cell_contents
+ (real_insert_row): function for class method insert_row
+ (real_remoce_row): function for class method remove_row
+ (real_sort_list): function for class method sort_list
+ (default_compare): fix to avoid problems with cell types != CELL_TEXT
+
+ * gtk/gtkctree.h :
+ (gtk_ctree_export_to_gnode): new function to export a ctree as gnode
+ (gtk_ctree_node_is_visible): new function to return visibility state
+ of a node
+ (gtk_ctree_show_stub): new function to set visibility of root stub
+
+ renamed functions :
+ (gtk_ctree_insert) -> (gtk_ctree_insert_node)
+ (gtk_ctree_remove) -> (gtk_ctree_remove_node)
+ (gtk_ctree_find_glist_ptr) -> (gtk_ctree_find_node_ptr)
+ (gtk_ctree_set_text) -> (gtk_ctree_node_set_text)
+ (gtk_ctree_set_pixmap) -> (gtk_ctree_node_set_pixmap)
+ (gtk_ctree_set_pixtext) -> (gtk_ctree_node_set_pixtext)
+ (gtk_ctree_set_shift) -> (gtk_ctree_node_set_shift)
+ (gtk_ctree_get_cell_type) -> (gtk_ctree_node_get_cell_type)
+ (gtk_ctree_get_text) -> (gtk_ctree_node_get_text)
+ (gtk_ctree_get_pixmap) -> (gtk_ctree_node_get_pixmap)
+ (gtk_ctree_get_pixtext) -> (gtk_ctree_node_get_pixtext)
+ (gtk_ctree_set_foreground) -> (gtk_ctree_node_set_foreground)
+ (gtk_ctree_set_background) -> (gtk_ctree_node_set_background)
+ (gtk_ctree_set_row_data) -> (gtk_ctree_node_set_row_data)
+ (gtk_ctree_set_row_data_full) -> (gtk_ctree_node_set_row_data_full)
+ (gtk_ctree_get_row_data) -> (gtk_ctree_node_get_row_data)
+ (gtk_ctree_moveto) -> (gtk_ctree_node_moveto)
+ (gtk_ctree_sort) -> (gtk_ctree_sort_node)
+ (gtk_ctree_is_visibe) -> (gtk_ctree_is_viewable)
+
+ * gtk/gtkctree.c :
+ (cell_empty) (cell_set_text) (cell_set_pixmap) (cell_set_pixtext):
+ removed and replaced by (set_cell_contents)
+ (set_cell_contents): function for class method set_cell_contents
+ (real_insert_row): function for class method insert_row
+ (real_remoce_row): function for class method remove_row
+ (real_sort_list): function for class method sort_list
+ (default_compare): removed. CTree now also compares two GtkCTreeRows
+ instead of two GtkCTreeNodes.
+ (gtk_ctree_unlink): call gtk_ctree_collapse if parent is empty after
+ unlinking the node
+ (real_tree_expand) (real_tree_collapse): fix for refcounting of
+ node pixmaps
+ (set_node_info): call gtk_ctree_node_set_pixtext instead of
+ manipulating the row itself
+
+ * gtk/testgtk.c: use renamed functions of GtkCTree.
+ new sample to show gtk_ctree_export_to_gnode and gtk_ctree_insert_gnode
+ at work.
+
Mon Aug 17 15:31:38 1998 Tim Janik <timj@gtk.org>
* gtk/gtkmain.c: removed gtk_input_add_interp.
static void row_delete (GtkCList * clist,
GtkCListRow * clist_row);
-static void cell_empty (GtkCList * clist,
- GtkCListRow * clist_row,
- gint column);
-static void cell_set_text (GtkCList * clist,
- GtkCListRow * clist_row,
- gint column,
- gchar * text);
-static void cell_set_pixmap (GtkCList * clist,
- GtkCListRow * clist_row,
- gint column,
- GdkPixmap * pixmap,
- GdkBitmap * mask);
-static void cell_set_pixtext (GtkCList * clist,
- GtkCListRow * clist_row,
- gint column,
- gchar * text,
- guint8 spacing,
- GdkPixmap * pixmap,
- GdkBitmap * mask);
+static void set_cell_contents (GtkCList * clist,
+ GtkCListRow * clist_row,
+ gint column,
+ GtkCellType type,
+ gchar * text,
+ guint8 spacing,
+ GdkPixmap * pixmap,
+ GdkBitmap * mask);
+static gint real_insert_row (GtkCList * clist,
+ gint row,
+ gchar * text[]);
+static void real_remove_row (GtkCList * clist,
+ gint row);
/* Focus handling */
static void gtk_clist_draw_focus (GtkWidget *widget);
static GList * gtk_clist_mergesort (GtkCList *clist,
GList *list,
gint num);
+static void real_sort_list (GtkCList *clist);
/* Fill in data after widget is realized and has style */
klass->selection_find = selection_find;
klass->click_column = NULL;
klass->draw_row = draw_row;
+ klass->insert_row = real_insert_row;
+ klass->remove_row = real_remove_row;
klass->clear = real_clear;
+ klass->sort_list = real_sort_list;
klass->select_all = real_select_all;
klass->unselect_all = real_unselect_all;
klass->fake_unselect_all = fake_unselect_all;
klass->start_selection = start_selection;
klass->end_selection = end_selection;
klass->abort_column_resize = abort_column_resize;
+ klass->set_cell_contents = set_cell_contents;
klass->scrollbar_spacing = 5;
clist_row = (g_list_nth (clist->row_list, row))->data;
/* if text is null, then the cell is empty */
- if (text)
- cell_set_text (clist, clist_row, column, text);
- else
- cell_empty (clist, clist_row, column);
+ GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ (clist, clist_row, column, GTK_CELL_TEXT, text, 0, NULL, NULL);
/* redraw the list if it's not frozen */
if (!GTK_CLIST_FROZEN (clist))
if (mask) gdk_pixmap_ref (mask);
- cell_set_pixmap (clist, clist_row, column, pixmap, mask);
+ GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ (clist, clist_row, column, GTK_CELL_PIXMAP, NULL, 0, pixmap, mask);
/* redraw the list if it's not frozen */
if (!GTK_CLIST_FROZEN (clist))
gdk_pixmap_ref (pixmap);
if (mask) gdk_pixmap_ref (mask);
- cell_set_pixtext (clist, clist_row, column, text, spacing, pixmap, mask);
+ GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ (clist, clist_row, column, GTK_CELL_PIXTEXT, text, spacing, pixmap, mask);
/* redraw the list if it's not frozen */
if (!GTK_CLIST_FROZEN (clist))
g_return_val_if_fail (GTK_IS_CLIST (clist), -1);
g_return_val_if_fail (text != NULL, -1);
- return gtk_clist_insert (clist, clist->rows, text);
+ return GTK_CLIST_CLASS_FW (clist)->insert_row (clist, clist->rows, text);
}
gint
gtk_clist_insert (GtkCList * clist,
gint row,
gchar * text[])
+{
+ return GTK_CLIST_CLASS_FW (clist)->insert_row (clist, row, text);
+}
+
+static gint
+real_insert_row (GtkCList * clist,
+ gint row,
+ gchar * text[])
{
gint i;
GtkCListRow *clist_row;
/* set the text in the row's columns */
for (i = 0; i < clist->columns; i++)
if (text[i])
- cell_set_text (clist, clist_row, i, text[i]);
+ GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ (clist, clist_row, i, GTK_CELL_TEXT, text[i], 0, NULL ,NULL);
if (!clist->rows)
{
void
gtk_clist_remove (GtkCList * clist,
gint row)
+{
+ GTK_CLIST_CLASS_FW (clist)->remove_row (clist, row);
+}
+
+static void
+real_remove_row (GtkCList * clist,
+ gint row)
{
gint was_visible, was_selected;
GList *list;
clist_row = (g_list_nth (clist->row_list, row))->data;
clist_row->data = data;
clist_row->destroy = destroy;
-
- /* re-send the selected signal if data is changed/added
- * so the application can respond to the new data --
- * this could be questionable behavior */
- if (clist_row->state == GTK_STATE_SELECTED)
- select_row (clist, row, -1, NULL);
}
gpointer
* columns_delete
* row_new
* row_delete
- * cell_empty
- * cell_set_text
- * cell_set_pixmap
+ * set_cell_contents
*/
static GtkCListColumn *
columns_new (GtkCList * clist)
gint i;
for (i = 0; i < clist->columns; i++)
- cell_empty (clist, clist_row, i);
+ GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ (clist, clist_row, i, GTK_CELL_EMPTY, NULL, 0, NULL, NULL);
if (clist_row->destroy)
clist_row->destroy (clist_row->data);
}
static void
-cell_empty (GtkCList * clist,
- GtkCListRow * clist_row,
- gint column)
+set_cell_contents (GtkCList * clist,
+ GtkCListRow * clist_row,
+ gint column,
+ GtkCellType type,
+ gchar * text,
+ guint8 spacing,
+ GdkPixmap * pixmap,
+ GdkBitmap * mask)
{
+ g_return_if_fail (clist_row != NULL);
+
switch (clist_row->cell[column].type)
{
case GTK_CELL_EMPTY:
case GTK_CELL_PIXMAP:
gdk_pixmap_unref (GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap);
if (GTK_CELL_PIXMAP (clist_row->cell[column])->mask)
- gdk_bitmap_unref (GTK_CELL_PIXMAP (clist_row->cell[column])->mask);
+ gdk_bitmap_unref (GTK_CELL_PIXMAP (clist_row->cell[column])->mask);
break;
case GTK_CELL_PIXTEXT:
g_free (GTK_CELL_PIXTEXT (clist_row->cell[column])->text);
gdk_pixmap_unref (GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap);
if (GTK_CELL_PIXTEXT (clist_row->cell[column])->mask)
- gdk_bitmap_unref (GTK_CELL_PIXTEXT (clist_row->cell[column])->mask);
+ gdk_bitmap_unref (GTK_CELL_PIXTEXT (clist_row->cell[column])->mask);
break;
case GTK_CELL_WIDGET:
}
clist_row->cell[column].type = GTK_CELL_EMPTY;
-}
-static void
-cell_set_text (GtkCList * clist,
- GtkCListRow * clist_row,
- gint column,
- gchar * text)
-{
- cell_empty (clist, clist_row, column);
-
- if (text)
+ switch (type)
{
- clist_row->cell[column].type = GTK_CELL_TEXT;
- GTK_CELL_TEXT (clist_row->cell[column])->text = g_strdup (text);
- }
-}
-
-static void
-cell_set_pixmap (GtkCList * clist,
- GtkCListRow * clist_row,
- gint column,
- GdkPixmap * pixmap,
- GdkBitmap * mask)
-{
- cell_empty (clist, clist_row, column);
+ case GTK_CELL_TEXT:
+ if (text)
+ {
+ clist_row->cell[column].type = GTK_CELL_TEXT;
+ GTK_CELL_TEXT (clist_row->cell[column])->text = g_strdup (text);
+ }
+ break;
- if (pixmap)
- {
- clist_row->cell[column].type = GTK_CELL_PIXMAP;
- GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap = pixmap;
- /* We set the mask even if it is NULL */
- GTK_CELL_PIXMAP (clist_row->cell[column])->mask = mask;
- }
-}
+ case GTK_CELL_PIXMAP:
+ if (pixmap)
+ {
+ clist_row->cell[column].type = GTK_CELL_PIXMAP;
+ GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap = pixmap;
+ /* We set the mask even if it is NULL */
+ GTK_CELL_PIXMAP (clist_row->cell[column])->mask = mask;
+ }
+ break;
-static void
-cell_set_pixtext (GtkCList * clist,
- GtkCListRow * clist_row,
- gint column,
- gchar * text,
- guint8 spacing,
- GdkPixmap * pixmap,
- GdkBitmap * mask)
-{
- cell_empty (clist, clist_row, column);
+ case GTK_CELL_PIXTEXT:
+ if (text && pixmap)
+ {
+ clist_row->cell[column].type = GTK_CELL_PIXTEXT;
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->text = g_strdup (text);
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->spacing = spacing;
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap = pixmap;
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->mask = mask;
+ }
+ break;
- if (text && pixmap)
- {
- clist_row->cell[column].type = GTK_CELL_PIXTEXT;
- GTK_CELL_PIXTEXT (clist_row->cell[column])->text = g_strdup (text);
- GTK_CELL_PIXTEXT (clist_row->cell[column])->spacing = spacing;
- GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap = pixmap;
- GTK_CELL_PIXTEXT (clist_row->cell[column])->mask = mask;
+ default:
+ break;
}
}
gconstpointer ptr1,
gconstpointer ptr2)
{
+ char *text1 = NULL;
+ char *text2 = NULL;
+
GtkCListRow *row1 = (GtkCListRow *) ptr1;
GtkCListRow *row2 = (GtkCListRow *) ptr2;
- char *text1;
- char *text2;
-
- text1 = GTK_CELL_TEXT (row1->cell[clist->sort_column])->text;
- text2 = GTK_CELL_TEXT (row2->cell[clist->sort_column])->text;
-
+
+ switch (row1->cell[clist->sort_column].type)
+ {
+ case GTK_CELL_TEXT:
+ text1 = GTK_CELL_TEXT (row1->cell[clist->sort_column])->text;
+ break;
+ case GTK_CELL_PIXTEXT:
+ text1 = GTK_CELL_PIXTEXT (row1->cell[clist->sort_column])->text;
+ break;
+ default:
+ break;
+ }
+
+ switch (row2->cell[clist->sort_column].type)
+ {
+ case GTK_CELL_TEXT:
+ text2 = GTK_CELL_TEXT (row2->cell[clist->sort_column])->text;
+ break;
+ case GTK_CELL_PIXTEXT:
+ text2 = GTK_CELL_PIXTEXT (row2->cell[clist->sort_column])->text;
+ break;
+ default:
+ break;
+ }
+
+ if (!text2)
+ return (text1 != NULL);
+
+ if (!text1)
+ return -1;
+
return strcmp (text1, text2);
}
void
gtk_clist_sort (GtkCList *clist)
+{
+ GTK_CLIST_CLASS_FW (clist)->sort_list (clist);
+}
+
+static void
+real_sort_list (GtkCList *clist)
{
GList *list;
GList *work;
if (clist->rows <= 1)
return;
- if (GTK_WIDGET_HAS_GRAB (GTK_WIDGET (clist)))
+ if (gdk_pointer_is_grabbed () && GTK_WIDGET_HAS_GRAB (clist))
return;
if (clist->anchor != -1 && clist->selection_mode == GTK_SELECTION_EXTENDED)
void (*clear) (GtkCList * clist);
void (*fake_unselect_all) (GtkCList * clist,
gint row);
+ void (*sort_list) (GtkCList * clist);
+ gint (*insert_row) (GtkCList * clist,
+ gint row,
+ gchar * text[]);
+ void (*remove_row) (GtkCList * clist,
+ gint row);
+ void (*set_cell_contents) (GtkCList * clist,
+ GtkCListRow * clist_row,
+ gint column,
+ GtkCellType type,
+ gchar * text,
+ guint8 spacing,
+ GdkPixmap * pixmap,
+ GdkBitmap * mask);
gint scrollbar_spacing;
};
GtkCTreeRow *row);
static void tree_draw_node (GtkCTree *ctree,
GtkCTreeNode *node);
-static void cell_empty (GtkCList *clist,
+static void set_cell_contents (GtkCList *clist,
GtkCListRow *clist_row,
- gint column);
-static void cell_set_text (GtkCList *clist,
- GtkCListRow *clist_row,
- gint column,
- gchar *text);
-static void cell_set_pixmap (GtkCList *clist,
- GtkCListRow *clist_row,
- gint column,
- GdkPixmap *pixmap,
- GdkBitmap *mask);
-static void cell_set_pixtext (GtkCList *clist,
- GtkCListRow *clist_row,
gint column,
+ GtkCellType type,
gchar *text,
guint8 spacing,
GdkPixmap *pixmap,
static void tree_sort (GtkCTree *ctree,
GtkCTreeNode *node,
gpointer data);
-static gint default_compare (GtkCList *clist,
- gconstpointer ptr1,
- gconstpointer ptr2);
static void fake_unselect_all (GtkCList *clist,
gint row);
static GList * selection_find (GtkCList *clist,
static void select_row_recursive (GtkCTree *ctree,
GtkCTreeNode *node,
gpointer data);
+static gint real_insert_row (GtkCList *clist,
+ gint row,
+ gchar *text[]);
+static void real_remove_row (GtkCList *clist,
+ gint row);
+static void real_sort_list (GtkCList *clist);
static void set_mouse_cursor (GtkCTree *ctree,
gboolean enable);
static void check_cursor (GtkCTree *ctree);
clist_class->select_all = real_select_all;
clist_class->unselect_all = real_unselect_all;
clist_class->fake_unselect_all = fake_unselect_all;
+ clist_class->insert_row = real_insert_row;
+ clist_class->remove_row = real_remove_row;
+ clist_class->sort_list = real_sort_list;
+ clist_class->set_cell_contents = set_cell_contents;
klass->tree_select_row = real_tree_select;
klass->tree_unselect_row = real_tree_unselect;
ctree->drag_source = NULL;
ctree->drag_target = NULL;
ctree->insert_pos = GTK_CTREE_POS_AS_CHILD;
- GTK_CLIST (ctree)->compare = default_compare;
ctree->reorderable = FALSE;
ctree->use_icons = TRUE;
ctree->in_drag = FALSE;
ctree->drag_rect = FALSE;
ctree->line_style = GTK_CTREE_LINES_SOLID;
ctree->drag_compare = NULL;
+ ctree->show_stub = TRUE;
}
static void
(((GtkCTreeRow *)clist_row)->children &&
((GtkCTreeRow *)clist_row)->expanded)))
{
- work2 = gtk_ctree_find_glist_ptr
+ work2 = gtk_ctree_find_node_ptr
(ctree, (GtkCTreeRow *) clist_row);
if (GTK_CTREE_NODE_NEXT (work2))
}
gdk_draw_line (clist->clist_window, ctree->lines_gc,
- xcenter, clip_rectangle.y + offset_y, xcenter,
+ xcenter,
+ (ctree->show_stub ||
+ clist->row_list->data != clist_row) ?
+ clip_rectangle.y + offset_y : ycenter,
+ xcenter,
(((GtkCTreeRow *)clist_row)->sibling) ?
rect->y + rect->height : ycenter);
(((GtkCTreeRow *)clist_row)->children &&
((GtkCTreeRow *)clist_row)->expanded)))
{
- work2 = gtk_ctree_find_glist_ptr
+ work2 = gtk_ctree_find_node_ptr
(ctree, (GtkCTreeRow *) clist_row);
if (GTK_CTREE_NODE_NEXT (work2))
clist = GTK_CLIST (ctree);
- if (!GTK_CLIST_FROZEN (clist) && gtk_ctree_is_visible (ctree, node))
+ if (!GTK_CLIST_FROZEN (clist) && gtk_ctree_is_viewable (ctree, node))
{
GtkCTreeNode *work;
gint num = 0;
work = GTK_CTREE_NODE (clist->row_list);
- while (work != node)
+ while (work && work != node)
{
work = GTK_CTREE_NODE_NEXT (work);
num++;
}
- if (gtk_clist_row_is_visible (clist, num) != GTK_VISIBILITY_NONE)
+ if (work && gtk_clist_row_is_visible (clist, num) != GTK_VISIBILITY_NONE)
GTK_CLIST_CLASS_FW (clist)->draw_row
(clist, NULL, num, GTK_CLIST_ROW ((GList *) node));
}
gboolean visible = FALSE;
gint rows = 0;
- g_return_if_fail (!sibling || GTK_CTREE_ROW (sibling)->parent == parent);
+ if (sibling)
+ g_return_if_fail (GTK_CTREE_ROW (sibling)->parent == parent);
g_return_if_fail (node != NULL);
g_return_if_fail (node != sibling);
g_return_if_fail (node != parent);
GTK_CTREE_ROW (node)->parent = parent;
GTK_CTREE_ROW (node)->sibling = sibling;
- if (!parent || (parent && (gtk_ctree_is_visible (ctree, parent) &&
+ if (!parent || (parent && (gtk_ctree_is_viewable (ctree, parent) &&
GTK_CTREE_ROW (parent)->expanded)))
{
visible = TRUE;
}
if (sibling == GTK_CTREE_NODE (clist->row_list))
- GTK_CTREE_NODE (clist->row_list) = node;
+ clist->row_list = (GList *) node;
if (GTK_CTREE_NODE_PREV (sibling) &&
GTK_CTREE_NODE_NEXT (GTK_CTREE_NODE_PREV (sibling)) == sibling)
GTK_CTREE_NODE_NEXT (GTK_CTREE_NODE_PREV (sibling)) = node;
}
else
{
- GTK_CTREE_NODE (clist->row_list) = node;
+ clist->row_list = (GList *)node;
GTK_CTREE_NODE_PREV (node) = NULL;
GTK_CTREE_NODE_NEXT (list_end) = NULL;
}
gtk_ctree_pre_recursive (ctree, node, tree_update_level, NULL);
if (clist->row_list_end == NULL ||
- GTK_CTREE_NODE (clist->row_list_end->next) == node)
+ clist->row_list_end->next == (GList *)node)
GTK_CTREE_NODE (clist->row_list_end) = list_end;
if (visible && update_focus_row)
clist->undo_unselection = NULL;
}
- visible = gtk_ctree_is_visible (ctree, node);
+ visible = gtk_ctree_is_viewable (ctree, node);
/* clist->row_list_end unlinked ? */
if (visible &&
(GTK_CTREE_ROW (node)->children &&
gtk_ctree_is_ancestor (ctree, node,
GTK_CTREE_NODE (clist->row_list_end)))))
- GTK_CTREE_NODE (clist->row_list_end) = GTK_CTREE_NODE_PREV (node);
+ clist->row_list_end = (GList *) (GTK_CTREE_NODE_PREV (node));
/* update list */
rows = 0;
if (GTK_CTREE_ROW (parent)->children == node)
{
GTK_CTREE_ROW (parent)->children = GTK_CTREE_ROW (node)->sibling;
- if (!GTK_CTREE_ROW (parent)->children &&
- GTK_CTREE_ROW (parent)->pixmap_closed)
- {
- GTK_CTREE_ROW (parent)->expanded = FALSE;
- GTK_CELL_PIXTEXT
- (GTK_CTREE_ROW(parent)->row.cell[ctree->tree_column])->pixmap =
- GTK_CTREE_ROW (parent)->pixmap_closed;
- GTK_CELL_PIXTEXT
- (GTK_CTREE_ROW (parent)->row.cell[ctree->tree_column])->mask =
- GTK_CTREE_ROW (parent)->mask_closed;
- }
+ if (!GTK_CTREE_ROW (parent)->children)
+ gtk_ctree_collapse (ctree, parent);
}
else
{
}
else
{
- if (GTK_CTREE_NODE (clist->row_list) == node)
- GTK_CTREE_NODE (clist->row_list) = GTK_CTREE_ROW (node)->sibling;
+ if (clist->row_list == (GList *)node)
+ clist->row_list = (GList *) (GTK_CTREE_ROW (node)->sibling);
else
{
GtkCTreeNode *sibling;
else
new_sibling = GTK_CTREE_NODE (clist->row_list);
- while (new_sibling && clist->compare (clist, node, new_sibling) > 0)
+ while (new_sibling && clist->compare
+ (clist, GTK_CTREE_ROW (node), GTK_CTREE_ROW (new_sibling)) > 0)
new_sibling = GTK_CTREE_ROW (new_sibling)->sibling;
}
}
work = NULL;
- if (gtk_ctree_is_visible (ctree, node) ||
- gtk_ctree_is_visible (ctree, new_sibling))
+ if (gtk_ctree_is_viewable (ctree, node) ||
+ gtk_ctree_is_viewable (ctree, new_sibling))
work = GTK_CTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
gtk_ctree_unlink (ctree, node, FALSE);
if (work)
{
- while (work && !gtk_ctree_is_visible (ctree, work))
+ while (work && !gtk_ctree_is_viewable (ctree, work))
work = GTK_CTREE_ROW (work)->parent;
clist->focus_row = g_list_position (clist->row_list, (GList *)work);
clist->undo_anchor = clist->focus_row;
GTK_CTREE_ROW (node)->expanded = TRUE;
level = GTK_CTREE_ROW (node)->level;
+ if (GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap)
+ {
+ gdk_pixmap_unref
+ (GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap);
+
+ GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap = NULL;
+
+ if (GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask)
+ {
+ gdk_pixmap_unref
+ (GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask);
+ GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask = NULL;
+ }
+ }
+
if (GTK_CTREE_ROW (node)->pixmap_opened)
{
GTK_CELL_PIXTEXT
(GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap =
- GTK_CTREE_ROW (node)->pixmap_opened;
- GTK_CELL_PIXTEXT
- (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask =
- GTK_CTREE_ROW (node)->mask_opened;
+ gdk_pixmap_ref (GTK_CTREE_ROW (node)->pixmap_opened);
+
+ if (GTK_CTREE_ROW (node)->mask_opened)
+ GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask =
+ gdk_pixmap_ref (GTK_CTREE_ROW (node)->mask_opened);
}
work = GTK_CTREE_ROW (node)->children;
if (GTK_CTREE_NODE_NEXT (node))
GTK_CTREE_NODE_PREV (GTK_CTREE_NODE_NEXT (node)) = work;
else
- GTK_CTREE_NODE (clist->row_list_end) = work;
+ clist->row_list_end = (GList *)work;
GTK_CTREE_NODE_NEXT (node) = GTK_CTREE_ROW (node)->children;
- if (gtk_ctree_is_visible (ctree, node))
+ if (gtk_ctree_is_viewable (ctree, node))
{
row = g_list_position (clist->row_list, (GList *)node);
if (row < clist->focus_row)
GTK_CTREE_ROW (node)->expanded = FALSE;
level = GTK_CTREE_ROW (node)->level;
+ if (GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap)
+ {
+ gdk_pixmap_unref
+ (GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap);
+
+ GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap = NULL;
+
+ if (GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask)
+ {
+ gdk_pixmap_unref
+ (GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask);
+ GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask = NULL;
+ }
+ }
+
if (GTK_CTREE_ROW (node)->pixmap_closed)
{
GTK_CELL_PIXTEXT
(GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->pixmap =
- GTK_CTREE_ROW (node)->pixmap_closed;
- GTK_CELL_PIXTEXT
- (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask =
- GTK_CTREE_ROW (node)->mask_closed;
+ gdk_pixmap_ref (GTK_CTREE_ROW (node)->pixmap_closed);
+
+ if (GTK_CTREE_ROW (node)->mask_closed)
+ GTK_CELL_PIXTEXT
+ (GTK_CTREE_ROW (node)->row.cell[ctree->tree_column])->mask =
+ gdk_pixmap_ref (GTK_CTREE_ROW (node)->mask_closed);
}
work = GTK_CTREE_ROW (node)->children;
else
{
GTK_CTREE_NODE_NEXT (node) = NULL;
- GTK_CTREE_NODE (clist->row_list_end) = node;
+ clist->row_list_end = (GList *)node;
}
- if (gtk_ctree_is_visible (ctree, node))
+ if (gtk_ctree_is_viewable (ctree, node))
{
row = g_list_position (clist->row_list, (GList *)node);
if (row < clist->focus_row)
}
static void
-cell_set_text (GtkCList *clist,
- GtkCListRow *clist_row,
- gint column,
- gchar *text)
+set_cell_contents (GtkCList * clist,
+ GtkCListRow * clist_row,
+ gint column,
+ GtkCellType type,
+ gchar * text,
+ guint8 spacing,
+ GdkPixmap * pixmap,
+ GdkBitmap * mask)
{
- cell_empty (clist, clist_row, column);
+ GtkCTree *ctree;
- if (text)
- {
- clist_row->cell[column].type = GTK_CELL_TEXT;
- GTK_CELL_TEXT (clist_row->cell[column])->text = g_strdup (text);
- }
-}
+ g_return_if_fail (clist != NULL);
+ g_return_if_fail (GTK_IS_CTREE (clist));
+ g_return_if_fail (clist_row != NULL);
-static void
-cell_set_pixmap (GtkCList *clist,
- GtkCListRow *clist_row,
- gint column,
- GdkPixmap *pixmap,
- GdkBitmap *mask)
-{
- cell_empty (clist, clist_row, column);
+ ctree = GTK_CTREE (clist);
- if (pixmap)
+ switch (clist_row->cell[column].type)
{
- clist_row->cell[column].type = GTK_CELL_PIXMAP;
- GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap = pixmap;
- GTK_CELL_PIXMAP (clist_row->cell[column])->mask = mask;
+ case GTK_CELL_EMPTY:
+ break;
+
+ case GTK_CELL_TEXT:
+ g_free (GTK_CELL_TEXT (clist_row->cell[column])->text);
+ break;
+
+ case GTK_CELL_PIXMAP:
+ gdk_pixmap_unref (GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap);
+ if (GTK_CELL_PIXMAP (clist_row->cell[column])->mask)
+ gdk_bitmap_unref (GTK_CELL_PIXMAP (clist_row->cell[column])->mask);
+ break;
+
+ case GTK_CELL_PIXTEXT:
+ if (GTK_CELL_PIXTEXT (clist_row->cell[column])->text)
+ g_free (GTK_CELL_PIXTEXT (clist_row->cell[column])->text);
+ if (GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap)
+ {
+ gdk_pixmap_unref
+ (GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap);
+ if (GTK_CELL_PIXTEXT (clist_row->cell[column])->mask)
+ gdk_bitmap_unref
+ (GTK_CELL_PIXTEXT (clist_row->cell[column])->mask);
+ }
+ break;
+
+ case GTK_CELL_WIDGET:
+ /* unimplimented */
+ break;
+
+ default:
+ break;
}
-}
-static void
-cell_set_pixtext (GtkCList *clist,
- GtkCListRow *clist_row,
- gint column,
- gchar *text,
- guint8 spacing,
- GdkPixmap *pixmap,
- GdkBitmap *mask)
-{
- cell_empty (clist, clist_row, column);
+ clist_row->cell[column].type = GTK_CELL_EMPTY;
+ if (column == ctree->tree_column && type != GTK_CELL_EMPTY)
+ type = GTK_CELL_PIXTEXT;
- if (text && pixmap)
+ switch (type)
{
- clist_row->cell[column].type = GTK_CELL_PIXTEXT;
- GTK_CELL_PIXTEXT (clist_row->cell[column])->text = g_strdup (text);
- GTK_CELL_PIXTEXT (clist_row->cell[column])->spacing = spacing;
- GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap = pixmap;
- GTK_CELL_PIXTEXT (clist_row->cell[column])->mask = mask;
+ case GTK_CELL_TEXT:
+ if (text)
+ {
+ clist_row->cell[column].type = GTK_CELL_TEXT;
+ GTK_CELL_TEXT (clist_row->cell[column])->text = g_strdup (text);
+ }
+ break;
+
+ case GTK_CELL_PIXMAP:
+ if (pixmap)
+ {
+ clist_row->cell[column].type = GTK_CELL_PIXMAP;
+ GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap = pixmap;
+ /* We set the mask even if it is NULL */
+ GTK_CELL_PIXMAP (clist_row->cell[column])->mask = mask;
+ }
+ break;
+
+ case GTK_CELL_PIXTEXT:
+ if (column == ctree->tree_column)
+ {
+ clist_row->cell[column].type = GTK_CELL_PIXTEXT;
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->spacing = spacing;
+ if (text)
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->text = g_strdup (text);
+ else
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->text = NULL;
+ if (pixmap)
+ {
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap = pixmap;
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->mask = mask;
+ }
+ else
+ {
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap = NULL;
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->mask = NULL;
+ }
+ }
+ else if (text && pixmap)
+ {
+ clist_row->cell[column].type = GTK_CELL_PIXTEXT;
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->text = g_strdup (text);
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->spacing = spacing;
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap = pixmap;
+ GTK_CELL_PIXTEXT (clist_row->cell[column])->mask = mask;
+ }
+ break;
+
+ default:
+ break;
}
}
gboolean is_leaf,
gboolean expanded)
{
- GtkCellPixText *tree_cell;
-
if (GTK_CTREE_ROW (node)->pixmap_opened)
{
gdk_pixmap_unref (GTK_CTREE_ROW (node)->pixmap_opened);
GTK_CTREE_ROW (node)->is_leaf = is_leaf;
GTK_CTREE_ROW (node)->expanded = (is_leaf) ? FALSE : expanded;
- GTK_CTREE_ROW (node)->row.cell[ctree->tree_column].type = GTK_CELL_PIXTEXT;
-
- tree_cell = GTK_CELL_PIXTEXT (GTK_CTREE_ROW
- (node)->row.cell[ctree->tree_column]);
-
- if (tree_cell->text)
- g_free (tree_cell->text);
-
- tree_cell->text = g_strdup (text);
- tree_cell->spacing = spacing;
-
if (GTK_CTREE_ROW (node)->expanded)
- {
- tree_cell->pixmap = pixmap_opened;
- tree_cell->mask = mask_opened;
- }
+ gtk_ctree_node_set_pixtext (ctree, node, ctree->tree_column,
+ text, spacing, pixmap_opened, mask_opened);
else
- {
- tree_cell->pixmap = pixmap_closed;
- tree_cell->mask = mask_closed;
- }
+ gtk_ctree_node_set_pixtext (ctree, node, ctree->tree_column,
+ text, spacing, pixmap_closed, mask_closed);
}
static void
clist = GTK_CLIST (ctree);
for (i = 0; i < clist->columns; i++)
- cell_empty (clist, &(ctree_row->row), i);
+ GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ (clist, &(ctree_row->row), i, GTK_CELL_EMPTY, NULL, 0, NULL, NULL);
if (ctree_row->pixmap_closed)
{
g_mem_chunk_free (clist->row_mem_chunk, ctree_row);
}
-static void
-cell_empty (GtkCList *clist,
- GtkCListRow *clist_row,
- gint column)
-{
- switch (clist_row->cell[column].type)
- {
- case GTK_CELL_EMPTY:
- break;
-
- case GTK_CELL_TEXT:
- g_free (GTK_CELL_TEXT (clist_row->cell[column])->text);
- break;
-
- case GTK_CELL_PIXMAP:
- gdk_pixmap_unref (GTK_CELL_PIXMAP (clist_row->cell[column])->pixmap);
- if (GTK_CELL_PIXMAP (clist_row->cell[column])->mask)
- gdk_bitmap_unref (GTK_CELL_PIXMAP (clist_row->cell[column])->mask);
- break;
-
- case GTK_CELL_PIXTEXT:
- if (GTK_CTREE (clist)->tree_column == column)
- {
- if (GTK_CELL_PIXTEXT (clist_row->cell[column])->text)
- g_free (GTK_CELL_PIXTEXT (clist_row->cell[column])->text);
- break;
- }
- g_free (GTK_CELL_PIXTEXT (clist_row->cell[column])->text);
- gdk_pixmap_unref (GTK_CELL_PIXTEXT (clist_row->cell[column])->pixmap);
- if (GTK_CELL_PIXTEXT (clist_row->cell[column])->mask)
- gdk_bitmap_unref (GTK_CELL_PIXTEXT (clist_row->cell[column])->mask);
- break;
-
- case GTK_CELL_WIDGET:
- /* unimplemented */
- break;
-
- default:
- break;
- }
-
- clist_row->cell[column].type = GTK_CELL_EMPTY;
-}
-
static void
real_select_row (GtkCList *clist,
gint row,
return (x >= xl && x <= xl + PM_SIZE && y >= yu && y <= yu + PM_SIZE);
}
-static gint
-default_compare (GtkCList *clist,
- gconstpointer ptr1,
- gconstpointer ptr2)
-{
- GtkCTreeNode *node1 = (GtkCTreeNode *) ptr1;
- GtkCTreeNode *node2 = (GtkCTreeNode *) ptr2;
- char *text1;
- char *text2;
-
- text1 = GTK_CELL_PIXTEXT (GTK_CTREE_ROW
- (node1)->row.cell[clist->sort_column])->text;
- text2 = GTK_CELL_PIXTEXT (GTK_CTREE_ROW
- (node2)->row.cell[clist->sort_column])->text;
-
- return strcmp (text1, text2);
-}
-
/***********************************************************
***********************************************************
*** Public interface ***
return gtk_ctree_new_with_titles (columns, tree_column, NULL);
}
+static gint
+real_insert_row (GtkCList *clist,
+ gint row,
+ gchar *text[])
+{
+ GtkCTreeNode *parent = NULL;
+ GtkCTreeNode *sibling;
+ GtkCTreeNode *node;
+
+ g_return_val_if_fail (clist != NULL, -1);
+ g_return_val_if_fail (GTK_IS_CTREE (clist), -1);
+
+ sibling = GTK_CTREE_NODE (g_list_nth (clist->row_list, row));
+ if (sibling)
+ parent = GTK_CTREE_ROW (sibling)->parent;
+
+ node = gtk_ctree_insert_node (GTK_CTREE (clist), parent, sibling, text, 5,
+ NULL, NULL, NULL, NULL, TRUE, FALSE);
+
+ if (GTK_CLIST_AUTO_SORT (clist) || !sibling)
+ return g_list_position (clist->row_list, (GList *) node);
+
+ return row;
+}
+
GtkCTreeNode *
-gtk_ctree_insert (GtkCTree *ctree,
- GtkCTreeNode *parent,
- GtkCTreeNode *sibling,
- gchar *text[],
- guint8 spacing,
- GdkPixmap *pixmap_closed,
- GdkBitmap *mask_closed,
- GdkPixmap *pixmap_opened,
- GdkBitmap *mask_opened,
- gboolean is_leaf,
- gboolean expanded)
+gtk_ctree_insert_node (GtkCTree *ctree,
+ GtkCTreeNode *parent,
+ GtkCTreeNode *sibling,
+ gchar *text[],
+ guint8 spacing,
+ GdkPixmap *pixmap_closed,
+ GdkBitmap *mask_closed,
+ GdkPixmap *pixmap_opened,
+ GdkBitmap *mask_opened,
+ gboolean is_leaf,
+ gboolean expanded)
{
GtkCList *clist;
GtkCTreeRow *new_row;
GtkCTreeNode *node;
+ GList *list;
gint i;
g_return_val_if_fail (ctree != NULL, NULL);
- g_return_val_if_fail (!sibling || GTK_CTREE_ROW (sibling)->parent == parent,
- NULL);
+ g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
+ if (sibling)
+ g_return_val_if_fail (GTK_CTREE_ROW (sibling)->parent == parent, NULL);
if (parent && GTK_CTREE_ROW (parent)->is_leaf)
return NULL;
/* create the row */
new_row = row_new (ctree);
- node = GTK_CTREE_NODE (g_list_alloc ());
- GTK_CTREE_ROW (node) = new_row;
+ list = g_list_alloc ();
+ list->data = new_row;
+ node = GTK_CTREE_NODE (list);
if (text)
for (i = 0; i < clist->columns; i++)
if (text[i] && i != ctree->tree_column)
- cell_set_text (clist, &(new_row->row), i, text[i]);
+ GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ (clist, &(new_row->row), i, GTK_CELL_TEXT, text[i], 0, NULL, NULL);
set_node_info (ctree, node, text[ctree->tree_column], spacing, pixmap_closed,
mask_closed, pixmap_opened, mask_opened, is_leaf, expanded);
else
sibling = GTK_CTREE_NODE (clist->row_list);
- while (sibling && clist->compare (clist, node, sibling) > 0)
+ while (sibling && clist->compare
+ (clist, GTK_CTREE_ROW (node), GTK_CTREE_ROW (sibling)) > 0)
sibling = GTK_CTREE_ROW (sibling)->sibling;
}
guint depth = 1;
g_return_val_if_fail (ctree != NULL, NULL);
+ g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
g_return_val_if_fail (gnode != NULL, NULL);
g_return_val_if_fail (func != NULL, NULL);
if (sibling)
if (parent)
depth = GTK_CTREE_ROW (parent)->level + 1;
- if (!(new_row = row_new (ctree)))
- return NULL;
- if (!(cnode = GTK_CTREE_NODE (g_list_alloc ())))
- return NULL;
+ new_row = row_new (ctree);
+ cnode = GTK_CTREE_NODE (g_list_alloc ());
GTK_CTREE_ROW (cnode) = new_row;
+ thaw = !GTK_CLIST_FROZEN (clist);
+ if (thaw)
+ gtk_clist_freeze (clist);
+
set_node_info (ctree, cnode, "", 0, NULL, NULL, NULL, NULL, TRUE, FALSE);
if (!func (ctree, depth, gnode, cnode, data))
return NULL;
}
- if ((thaw = !GTK_CLIST_FROZEN (clist)))
- gtk_clist_freeze (clist);
-
if (GTK_CLIST_AUTO_SORT (clist))
{
if (parent)
else
sibling = GTK_CTREE_NODE (clist->row_list);
- while (sibling && clist->compare (clist, cnode, sibling) > 0)
+ while (sibling && clist->compare
+ (clist, GTK_CTREE_ROW (cnode), GTK_CTREE_ROW (sibling)) > 0)
sibling = GTK_CTREE_ROW (sibling)->sibling;
}
return cnode;
}
+GNode *
+gtk_ctree_export_to_gnode (GtkCTree *ctree,
+ GNode *parent,
+ GNode *sibling,
+ GtkCTreeNode *node,
+ GtkCTreeGNodeFunc func,
+ gpointer data)
+{
+ GtkCTreeNode *work;
+ GNode *gnode;
+ GNode *new_sibling;
+ gint depth;
+
+ g_return_val_if_fail (ctree != NULL, NULL);
+ g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
+ g_return_val_if_fail (node != NULL, NULL);
+ g_return_val_if_fail (func != NULL, NULL);
+ if (sibling)
+ {
+ g_return_val_if_fail (parent != NULL, NULL);
+ g_return_val_if_fail (sibling->parent == parent, NULL);
+ }
+
+ gnode = g_node_new (NULL);
+ depth = g_node_depth (parent) + 1;
+
+ if (!func (ctree, depth, gnode, node, data))
+ {
+ g_node_destroy (gnode);
+ return NULL;
+ }
+
+ if (parent)
+ g_node_insert_before (parent, sibling, gnode);
+
+ for (work = GTK_CTREE_ROW (node)->children, new_sibling = NULL; work;
+ work = GTK_CTREE_NODE_NEXT (work))
+ {
+ sibling = gtk_ctree_export_to_gnode (ctree, gnode, new_sibling,
+ work, func, data);
+ if (sibling)
+ new_sibling = sibling;
+ }
+ g_node_reverse_children (gnode);
+
+ return gnode;
+}
+
+static void
+real_remove_row (GtkCList *clist,
+ gint row)
+{
+ GtkCTreeNode *node;
+
+ g_return_if_fail (clist != NULL);
+ g_return_if_fail (GTK_IS_CTREE (clist));
+
+ node = GTK_CTREE_NODE (g_list_nth (clist->row_list, row));
+
+ if (node)
+ gtk_ctree_remove_node (GTK_CTREE (clist), node);
+}
+
void
-gtk_ctree_remove (GtkCTree *ctree,
- GtkCTreeNode *node)
+gtk_ctree_remove_node (GtkCTree *ctree,
+ GtkCTreeNode *node)
{
GtkCList *clist;
gboolean thaw = FALSE;
}
gboolean
-gtk_ctree_is_visible (GtkCTree *ctree,
- GtkCTreeNode *node)
+gtk_ctree_is_viewable (GtkCTree *ctree,
+ GtkCTreeNode *node)
{
GtkCTreeRow *work;
}
GtkCTreeNode *
-gtk_ctree_find_glist_ptr (GtkCTree *ctree,
- GtkCTreeRow *ctree_row)
+gtk_ctree_find_node_ptr (GtkCTree *ctree,
+ GtkCTreeRow *ctree_row)
{
GtkCTreeNode *node;
if (node && GTK_CTREE_ROW (node)->is_leaf)
return;
- if (((node && gtk_ctree_is_visible (ctree, node)) || !node) &&
+ if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
!GTK_CLIST_FROZEN (clist))
{
gtk_clist_freeze (clist);
if (node && GTK_CTREE_ROW (node)->is_leaf)
return;
- if (((node && gtk_ctree_is_visible (ctree, node)) || !node) &&
+ if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
!GTK_CLIST_FROZEN (clist))
{
gtk_clist_freeze (clist);
clist = GTK_CLIST (ctree);
- if (((node && gtk_ctree_is_visible (ctree, node)) || !node) &&
+ if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
!GTK_CLIST_FROZEN (clist))
{
gtk_clist_freeze (clist);
clist = GTK_CLIST (ctree);
- if (((node && gtk_ctree_is_visible (ctree, node)) || !node) &&
+ if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
!GTK_CLIST_FROZEN (clist))
{
gtk_clist_freeze (clist);
clist = GTK_CLIST (ctree);
- if (((node && gtk_ctree_is_visible (ctree, node)) || !node) &&
+ if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
!GTK_CLIST_FROZEN (clist))
{
gtk_clist_freeze (clist);
(!state && clist->selection_mode == GTK_SELECTION_BROWSE))
return;
- if (((node && gtk_ctree_is_visible (ctree, node)) || !node) &&
+ if (((node && gtk_ctree_is_viewable (ctree, node)) || !node) &&
!GTK_CLIST_FROZEN (clist))
{
gtk_clist_freeze (clist);
void
-gtk_ctree_set_text (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- gchar *text)
+gtk_ctree_node_set_text (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ gchar *text)
{
+ GtkCList *clist;
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
- g_return_if_fail (ctree->tree_column != column);
if (column < 0 || column >= GTK_CLIST (ctree)->columns)
return;
+
+ clist = GTK_CLIST (ctree);
+
+ GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ (clist, &(GTK_CTREE_ROW(node)->row), column, GTK_CELL_TEXT,
+ text, 0, NULL, NULL);
- cell_set_text (GTK_CLIST (ctree), &(GTK_CTREE_ROW(node)->row), column, text);
tree_draw_node (ctree, node);
}
void
-gtk_ctree_set_pixmap (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- GdkPixmap *pixmap,
- GdkBitmap *mask)
+gtk_ctree_node_set_pixmap (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ GdkPixmap *pixmap,
+ GdkBitmap *mask)
{
+ GtkCList *clist;
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
g_return_if_fail (pixmap != NULL);
- g_return_if_fail (ctree->tree_column != column);
if (column < 0 || column >= GTK_CLIST (ctree)->columns)
return;
if (mask)
gdk_pixmap_ref (mask);
- cell_set_pixmap (GTK_CLIST (ctree), &(GTK_CTREE_ROW (node)->row), column,
- pixmap, mask);
+ clist = GTK_CLIST (ctree);
+
+ GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ (clist, &(GTK_CTREE_ROW (node)->row), column, GTK_CELL_PIXMAP,
+ NULL, 0, pixmap, mask);
+
tree_draw_node (ctree, node);
}
void
-gtk_ctree_set_pixtext (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- gchar *text,
- guint8 spacing,
- GdkPixmap *pixmap,
- GdkBitmap *mask)
+gtk_ctree_node_set_pixtext (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ gchar *text,
+ guint8 spacing,
+ GdkPixmap *pixmap,
+ GdkBitmap *mask)
{
+ GtkCList *clist;
+
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
g_return_if_fail (node != NULL);
- g_return_if_fail (pixmap != NULL);
- g_return_if_fail (ctree->tree_column != column);
-
+ if (column != ctree->tree_column)
+ g_return_if_fail (pixmap != NULL);
if (column < 0 || column >= GTK_CLIST (ctree)->columns)
return;
- gdk_pixmap_ref (pixmap);
- if (mask)
- gdk_pixmap_ref (mask);
+ clist = GTK_CLIST (ctree);
+
+ if (pixmap)
+ {
+ gdk_pixmap_ref (pixmap);
+ if (mask)
+ gdk_pixmap_ref (mask);
+ }
+
+ GTK_CLIST_CLASS_FW (clist)->set_cell_contents
+ (clist, &(GTK_CTREE_ROW (node)->row), column, GTK_CELL_PIXTEXT,
+ text, spacing, pixmap, mask);
- cell_set_pixtext (GTK_CLIST (ctree), &(GTK_CTREE_ROW (node)->row), column,
- text, spacing, pixmap, mask);
tree_draw_node (ctree, node);
}
{
ptr = work;
work = GTK_CTREE_ROW(work)->sibling;
- gtk_ctree_remove (ctree, ptr);
+ gtk_ctree_remove_node (ctree, ptr);
}
}
}
void
-gtk_ctree_set_shift (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- gint vertical,
- gint horizontal)
+gtk_ctree_node_set_shift (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ gint vertical,
+ gint horizontal)
{
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
}
GtkCellType
-gtk_ctree_get_cell_type (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column)
+gtk_ctree_node_get_cell_type (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column)
{
g_return_val_if_fail (ctree != NULL, -1);
g_return_val_if_fail (GTK_IS_CTREE (ctree), -1);
}
gint
-gtk_ctree_get_text (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- gchar **text)
+gtk_ctree_node_get_text (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ gchar **text)
{
g_return_val_if_fail (ctree != NULL, 0);
g_return_val_if_fail (GTK_IS_CTREE (ctree), 0);
}
gint
-gtk_ctree_get_pixmap (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- GdkPixmap **pixmap,
- GdkBitmap **mask)
+gtk_ctree_node_get_pixmap (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ GdkPixmap **pixmap,
+ GdkBitmap **mask)
{
g_return_val_if_fail (ctree != NULL, 0);
g_return_val_if_fail (GTK_IS_CTREE (ctree), 0);
}
gint
-gtk_ctree_get_pixtext (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- gchar **text,
- guint8 *spacing,
- GdkPixmap **pixmap,
- GdkBitmap **mask)
+gtk_ctree_node_get_pixtext (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ gchar **text,
+ guint8 *spacing,
+ GdkPixmap **pixmap,
+ GdkBitmap **mask)
{
g_return_val_if_fail (ctree != NULL, 0);
g_return_val_if_fail (GTK_IS_CTREE (ctree), 0);
}
void
-gtk_ctree_set_foreground (GtkCTree *ctree,
- GtkCTreeNode *node,
- GdkColor *color)
+gtk_ctree_node_set_foreground (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ GdkColor *color)
{
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
}
void
-gtk_ctree_set_background (GtkCTree *ctree,
- GtkCTreeNode *node,
- GdkColor *color)
+gtk_ctree_node_set_background (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ GdkColor *color)
{
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
}
void
-gtk_ctree_set_row_data (GtkCTree *ctree,
- GtkCTreeNode *node,
- gpointer data)
+gtk_ctree_node_set_row_data (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gpointer data)
{
- gtk_ctree_set_row_data_full (ctree, node, data, NULL);
+ gtk_ctree_node_set_row_data_full (ctree, node, data, NULL);
}
void
-gtk_ctree_set_row_data_full (GtkCTree *ctree,
- GtkCTreeNode *node,
- gpointer data,
- GtkDestroyNotify destroy)
+gtk_ctree_node_set_row_data_full (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gpointer data,
+ GtkDestroyNotify destroy)
{
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
}
gpointer
-gtk_ctree_get_row_data (GtkCTree *ctree,
- GtkCTreeNode *node)
+gtk_ctree_node_get_row_data (GtkCTree *ctree,
+ GtkCTreeNode *node)
{
g_return_val_if_fail (ctree != NULL, NULL);
g_return_val_if_fail (GTK_IS_CTREE (ctree), NULL);
}
void
-gtk_ctree_moveto (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- gfloat row_align,
- gfloat col_align)
+gtk_ctree_node_moveto (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ gfloat row_align,
+ gfloat col_align)
{
gint row = -1;
GtkCList *clist;
clist = GTK_CLIST (ctree);
- while (node && !gtk_ctree_is_visible (ctree, node))
+ while (node && !gtk_ctree_is_viewable (ctree, node))
node = GTK_CTREE_ROW (node)->parent;
if (node)
gtk_clist_moveto (clist, row, column, row_align, col_align);
}
+GtkVisibility gtk_ctree_node_is_visible (GtkCTree *ctree,
+ GtkCTreeNode *node)
+{
+ gint row;
+
+ g_return_val_if_fail (ctree != NULL, 0);
+ g_return_val_if_fail (node != NULL, 0);
+
+ row = g_list_position (GTK_CLIST (ctree)->row_list, (GList*) node);
+ return gtk_clist_row_is_visible (GTK_CLIST (ctree), row);
+}
+
/***********************************************************
* GtkCTree specific functions *
}
}
+void
+gtk_ctree_show_stub (GtkCTree *ctree,
+ gboolean show_stub)
+{
+ g_return_if_fail (ctree != NULL);
+ g_return_if_fail (GTK_IS_CTREE (ctree));
+
+ if (show_stub != ctree->show_stub)
+ {
+ GtkCList *clist;
+
+ clist = GTK_CLIST (ctree);
+ ctree->show_stub = show_stub;
+
+ if (!GTK_CLIST_FROZEN (clist) && clist->rows &&
+ gtk_clist_row_is_visible (clist, 0) != GTK_VISIBILITY_NONE)
+ GTK_CLIST_CLASS_FW (clist)->draw_row
+ (clist, NULL, 0, GTK_CLIST_ROW (clist->row_list));
+ }
+}
+
void
gtk_ctree_set_reorderable (GtkCTree *ctree,
gboolean reorderable)
{
if (clist->sort_type == GTK_SORT_ASCENDING)
{
- if (clist->compare (clist, work, cmp) < 0)
+ if (clist->compare
+ (clist, GTK_CTREE_ROW (work), GTK_CTREE_ROW (cmp)) < 0)
cmp = work;
}
else
{
- if (clist->compare (clist, work, cmp) > 0)
+ if (clist->compare
+ (clist, GTK_CTREE_ROW (work), GTK_CTREE_ROW (cmp)) > 0)
cmp = work;
}
work = GTK_CTREE_ROW (work)->sibling;
clist->undo_unselection = NULL;
}
- if (!node || (node && gtk_ctree_is_visible (ctree, node)))
+ if (!node || (node && gtk_ctree_is_viewable (ctree, node)))
focus_node =
GTK_CTREE_NODE (g_list_nth (clist->row_list, clist->focus_row));
gtk_clist_thaw (clist);
}
+static void
+real_sort_list (GtkCList *clist)
+{
+ gtk_ctree_sort_recursive (GTK_CTREE (clist), NULL);
+}
+
void
-gtk_ctree_sort (GtkCTree *ctree,
- GtkCTreeNode *node)
+gtk_ctree_sort_node (GtkCTree *ctree,
+ GtkCTreeNode *node)
{
GtkCList *clist;
GtkCTreeNode *focus_node = NULL;
clist->undo_unselection = NULL;
}
- if (!node || (node && gtk_ctree_is_visible (ctree, node)))
+ if (!node || (node && gtk_ctree_is_viewable (ctree, node)))
focus_node = GTK_CTREE_NODE
(g_list_nth (clist->row_list, clist->focus_row));
unselect = TRUE;
- if (gtk_ctree_is_visible (ctree, node))
+ if (gtk_ctree_is_viewable (ctree, node))
{
row = g_list_position (clist->row_list, (GList *)node);
if (row >= i && row <= e)
}
void
-gtk_ctree_set_drag_compare_func (GtkCTree *ctree, GtkCTreeCompareDragFunc cmp_func)
+gtk_ctree_set_drag_compare_func (GtkCTree *ctree,
+ GtkCTreeCompareDragFunc cmp_func)
{
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
}
static void
-set_mouse_cursor(GtkCTree *ctree, gboolean enable)
+set_mouse_cursor (GtkCTree *ctree,
+ gboolean enable)
{
GdkCursor *cursor;
else
cursor = gdk_cursor_new (GDK_CIRCLE);
- gdk_window_set_cursor (GTK_CLIST(ctree)->clist_window, cursor);
+ gdk_window_set_cursor (GTK_CLIST (ctree)->clist_window, cursor);
gdk_cursor_destroy (cursor);
}
static void
-check_cursor(GtkCTree *ctree)
+check_cursor (GtkCTree *ctree)
{
g_return_if_fail (ctree != NULL);
g_return_if_fail (GTK_IS_CTREE (ctree));
-
if (!GTK_CTREE_ROW (ctree->drag_source)->children ||
!gtk_ctree_is_ancestor (ctree, ctree->drag_source, ctree->drag_target))
{
- if (ctree->insert_pos == GTK_CTREE_POS_AFTER)
- {
- if (GTK_CTREE_ROW (ctree->drag_target)->sibling != ctree->drag_source)
- set_mouse_cursor( ctree, (!ctree->drag_compare ||
- ctree->drag_compare (ctree,
- ctree->drag_source,
- GTK_CTREE_ROW (ctree->drag_target)->parent,
- GTK_CTREE_ROW (ctree->drag_target)->sibling)));
- }
- else if (ctree->insert_pos == GTK_CTREE_POS_BEFORE)
- {
- if (GTK_CTREE_ROW (ctree->drag_source)->sibling != ctree->drag_target)
- set_mouse_cursor( ctree, (!ctree->drag_compare ||
- ctree->drag_compare (ctree,
- ctree->drag_source,
- GTK_CTREE_ROW (ctree->drag_target)->parent,
- ctree->drag_target)));
- }
- else if (!GTK_CTREE_ROW (ctree->drag_target)->is_leaf)
- {
- if (GTK_CTREE_ROW (ctree->drag_target)->children != ctree->drag_source)
- set_mouse_cursor( ctree, (!ctree->drag_compare ||
- ctree->drag_compare (ctree,
- ctree->drag_source,
- ctree->drag_target,
- GTK_CTREE_ROW (ctree->drag_target)->children)));
- }
+ if (ctree->insert_pos == GTK_CTREE_POS_AFTER)
+ {
+ if (GTK_CTREE_ROW (ctree->drag_target)->sibling !=
+ ctree->drag_source)
+ set_mouse_cursor
+ (ctree,
+ (!ctree->drag_compare ||
+ ctree->drag_compare
+ (ctree,
+ ctree->drag_source,
+ GTK_CTREE_ROW (ctree->drag_target)->parent,
+ GTK_CTREE_ROW (ctree->drag_target)->sibling)));
+ }
+ else if (ctree->insert_pos == GTK_CTREE_POS_BEFORE)
+ {
+ if (GTK_CTREE_ROW (ctree->drag_source)->sibling !=
+ ctree->drag_target)
+ set_mouse_cursor
+ (ctree,
+ (!ctree->drag_compare ||
+ ctree->drag_compare
+ (ctree,
+ ctree->drag_source,
+ GTK_CTREE_ROW (ctree->drag_target)->parent,
+ ctree->drag_target)));
+ }
+ else if (!GTK_CTREE_ROW (ctree->drag_target)->is_leaf)
+ {
+ if (GTK_CTREE_ROW (ctree->drag_target)->children !=
+ ctree->drag_source)
+ set_mouse_cursor
+ (ctree,
+ (!ctree->drag_compare ||
+ ctree->drag_compare
+ (ctree,
+ ctree->drag_source,
+ ctree->drag_target,
+ GTK_CTREE_ROW (ctree->drag_target)->children)));
+ }
}
else
set_mouse_cursor(ctree, FALSE);
#define GTK_CTREE_NODE(_node_) ((GtkCTreeNode *)((_node_)))
#define GTK_CTREE_NODE_NEXT(_nnode_) ((GtkCTreeNode *)(((GList *)(_nnode_))->next))
#define GTK_CTREE_NODE_PREV(_pnode_) ((GtkCTreeNode *)(((GList *)(_pnode_))->prev))
-#define GTK_CTREE_TREE(_ctree_, _glist_) \
- ((GtkCellTree *) &(((GtkCTreeRow *)((_glist_)->data))->cell[(_ctree_)->tree_col]))
-
#define GTK_CTREE_FUNC(_func_) ((GtkCTreeFunc)(_func_))
typedef enum
guint in_drag : 1;
guint drag_rect : 1;
guint line_style : 2;
+ guint show_stub : 1;
GtkCTreeCompareDragFunc drag_compare;
};
* Creation, insertion, deletion *
***********************************************************/
-GtkType gtk_ctree_get_type (void);
-void gtk_ctree_construct (GtkCTree *ctree,
- gint columns,
- gint tree_column,
- gchar *titles[]);
-GtkWidget * gtk_ctree_new_with_titles (gint columns,
- gint tree_column,
- gchar *titles[]);
-GtkWidget * gtk_ctree_new (gint columns,
- gint tree_column);
-GtkCTreeNode * gtk_ctree_insert (GtkCTree *ctree,
- GtkCTreeNode *parent,
- GtkCTreeNode *sibling,
- gchar *text[],
- guint8 spacing,
- GdkPixmap *pixmap_closed,
- GdkBitmap *mask_closed,
- GdkPixmap *pixmap_opened,
- GdkBitmap *mask_opened,
- gboolean is_leaf,
- gboolean expanded);
-GtkCTreeNode * gtk_ctree_insert_gnode (GtkCTree *ctree,
- GtkCTreeNode *parent,
- GtkCTreeNode *sibling,
- GNode *gnode,
- GtkCTreeGNodeFunc func,
- gpointer data);
-void gtk_ctree_remove (GtkCTree *ctree,
- GtkCTreeNode *node);
+GtkType gtk_ctree_get_type (void);
+void gtk_ctree_construct (GtkCTree *ctree,
+ gint columns,
+ gint tree_column,
+ gchar *titles[]);
+GtkWidget * gtk_ctree_new_with_titles (gint columns,
+ gint tree_column,
+ gchar *titles[]);
+GtkWidget * gtk_ctree_new (gint columns,
+ gint tree_column);
+GtkCTreeNode * gtk_ctree_insert_node (GtkCTree *ctree,
+ GtkCTreeNode *parent,
+ GtkCTreeNode *sibling,
+ gchar *text[],
+ guint8 spacing,
+ GdkPixmap *pixmap_closed,
+ GdkBitmap *mask_closed,
+ GdkPixmap *pixmap_opened,
+ GdkBitmap *mask_opened,
+ gboolean is_leaf,
+ gboolean expanded);
+void gtk_ctree_remove_node (GtkCTree *ctree,
+ GtkCTreeNode *node);
+GtkCTreeNode * gtk_ctree_insert_gnode (GtkCTree *ctree,
+ GtkCTreeNode *parent,
+ GtkCTreeNode *sibling,
+ GNode *gnode,
+ GtkCTreeGNodeFunc func,
+ gpointer data);
+GNode * gtk_ctree_export_to_gnode (GtkCTree *ctree,
+ GNode *parent,
+ GNode *sibling,
+ GtkCTreeNode *node,
+ GtkCTreeGNodeFunc func,
+ gpointer data);
/***********************************************************
* Generic recursive functions, querying / finding tree *
* information *
***********************************************************/
-void gtk_ctree_post_recursive (GtkCTree *ctree,
- GtkCTreeNode *node,
- GtkCTreeFunc func,
- gpointer data);
-void gtk_ctree_post_recursive_to_depth (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint depth,
- GtkCTreeFunc func,
- gpointer data);
-void gtk_ctree_pre_recursive (GtkCTree *ctree,
- GtkCTreeNode *node,
- GtkCTreeFunc func,
- gpointer data);
-void gtk_ctree_pre_recursive_to_depth (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint depth,
- GtkCTreeFunc func,
- gpointer data);
-gboolean gtk_ctree_is_visible (GtkCTree *ctree,
- GtkCTreeNode *node);
-GtkCTreeNode * gtk_ctree_last (GtkCTree *ctree,
- GtkCTreeNode *node);
-GtkCTreeNode * gtk_ctree_find_glist_ptr (GtkCTree *ctree,
- GtkCTreeRow *ctree_row);
-gboolean gtk_ctree_find (GtkCTree *ctree,
- GtkCTreeNode *node,
- GtkCTreeNode *child);
-gboolean gtk_ctree_is_ancestor (GtkCTree *ctree,
- GtkCTreeNode *node,
- GtkCTreeNode *child);
-GtkCTreeNode * gtk_ctree_find_by_row_data (GtkCTree *ctree,
- GtkCTreeNode *node,
- gpointer data);
+void gtk_ctree_post_recursive (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ GtkCTreeFunc func,
+ gpointer data);
+void gtk_ctree_post_recursive_to_depth (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint depth,
+ GtkCTreeFunc func,
+ gpointer data);
+void gtk_ctree_pre_recursive (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ GtkCTreeFunc func,
+ gpointer data);
+void gtk_ctree_pre_recursive_to_depth (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint depth,
+ GtkCTreeFunc func,
+ gpointer data);
+gboolean gtk_ctree_is_viewable (GtkCTree *ctree,
+ GtkCTreeNode *node);
+GtkCTreeNode * gtk_ctree_last (GtkCTree *ctree,
+ GtkCTreeNode *node);
+GtkCTreeNode * gtk_ctree_find_node_ptr (GtkCTree *ctree,
+ GtkCTreeRow *ctree_row);
+gboolean gtk_ctree_find (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ GtkCTreeNode *child);
+gboolean gtk_ctree_is_ancestor (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ GtkCTreeNode *child);
+GtkCTreeNode * gtk_ctree_find_by_row_data (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gpointer data);
GtkCTreeNode * gtk_ctree_find_by_row_data_custom (GtkCTree *ctree,
GtkCTreeNode *node,
gpointer data,
GCompareFunc func);
-gboolean gtk_ctree_is_hot_spot (GtkCTree *ctree,
- gint x,
- gint y);
+gboolean gtk_ctree_is_hot_spot (GtkCTree *ctree,
+ gint x,
+ gint y);
/***********************************************************
* Tree signals : move, expand, collapse, (un)select *
***********************************************************/
-void gtk_ctree_move (GtkCTree *ctree,
- GtkCTreeNode *node,
- GtkCTreeNode *new_parent,
- GtkCTreeNode *new_sibling);
-void gtk_ctree_expand (GtkCTree *ctree,
- GtkCTreeNode *node);
-void gtk_ctree_expand_recursive (GtkCTree *ctree,
- GtkCTreeNode *node);
-void gtk_ctree_expand_to_depth (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint depth);
-void gtk_ctree_collapse (GtkCTree *ctree,
- GtkCTreeNode *node);
-void gtk_ctree_collapse_recursive (GtkCTree *ctree,
- GtkCTreeNode *node);
-void gtk_ctree_collapse_to_depth (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint depth);
-void gtk_ctree_toggle_expansion (GtkCTree *ctree,
- GtkCTreeNode *node);
-void gtk_ctree_toggle_expansion_recursive (GtkCTree *ctree,
- GtkCTreeNode *node);
-void gtk_ctree_select (GtkCTree *ctree,
- GtkCTreeNode *node);
-void gtk_ctree_select_recursive (GtkCTree *ctree,
- GtkCTreeNode *node);
-void gtk_ctree_unselect (GtkCTree *ctree,
- GtkCTreeNode *node);
-void gtk_ctree_unselect_recursive (GtkCTree *ctree,
- GtkCTreeNode *node);
-void gtk_ctree_real_select_recursive (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint state);
+void gtk_ctree_move (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ GtkCTreeNode *new_parent,
+ GtkCTreeNode *new_sibling);
+void gtk_ctree_expand (GtkCTree *ctree,
+ GtkCTreeNode *node);
+void gtk_ctree_expand_recursive (GtkCTree *ctree,
+ GtkCTreeNode *node);
+void gtk_ctree_expand_to_depth (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint depth);
+void gtk_ctree_collapse (GtkCTree *ctree,
+ GtkCTreeNode *node);
+void gtk_ctree_collapse_recursive (GtkCTree *ctree,
+ GtkCTreeNode *node);
+void gtk_ctree_collapse_to_depth (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint depth);
+void gtk_ctree_toggle_expansion (GtkCTree *ctree,
+ GtkCTreeNode *node);
+void gtk_ctree_toggle_expansion_recursive (GtkCTree *ctree,
+ GtkCTreeNode *node);
+void gtk_ctree_select (GtkCTree *ctree,
+ GtkCTreeNode *node);
+void gtk_ctree_select_recursive (GtkCTree *ctree,
+ GtkCTreeNode *node);
+void gtk_ctree_unselect (GtkCTree *ctree,
+ GtkCTreeNode *node);
+void gtk_ctree_unselect_recursive (GtkCTree *ctree,
+ GtkCTreeNode *node);
+void gtk_ctree_real_select_recursive (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint state);
/***********************************************************
* Analogons of GtkCList functions *
***********************************************************/
-void gtk_ctree_set_text (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- gchar *text);
-void gtk_ctree_set_pixmap (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- GdkPixmap *pixmap,
- GdkBitmap *mask);
-void gtk_ctree_set_pixtext (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- gchar *text,
- guint8 spacing,
- GdkPixmap *pixmap,
- GdkBitmap *mask);
-void gtk_ctree_set_node_info (GtkCTree *ctree,
- GtkCTreeNode *node,
- gchar *text,
- guint8 spacing,
- GdkPixmap *pixmap_closed,
- GdkBitmap *mask_closed,
- GdkPixmap *pixmap_opened,
- GdkBitmap *mask_opened,
- gboolean is_leaf,
- gboolean expanded);
-void gtk_ctree_set_shift (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- gint vertical,
- gint horizontal);
-GtkCellType gtk_ctree_get_cell_type (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column);
-gint gtk_ctree_get_text (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- gchar **text);
-gint gtk_ctree_get_pixmap (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- GdkPixmap **pixmap,
- GdkBitmap **mask);
-gint gtk_ctree_get_pixtext (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- gchar **text,
- guint8 *spacing,
- GdkPixmap **pixmap,
- GdkBitmap **mask);
-gint gtk_ctree_get_node_info (GtkCTree *ctree,
- GtkCTreeNode *node,
- gchar **text,
- guint8 *spacing,
- GdkPixmap **pixmap_closed,
- GdkBitmap **mask_closed,
- GdkPixmap **pixmap_opened,
- GdkBitmap **mask_opened,
- gboolean *is_leaf,
- gboolean *expanded);
-void gtk_ctree_set_foreground (GtkCTree *ctree,
- GtkCTreeNode *node,
- GdkColor *color);
-void gtk_ctree_set_background (GtkCTree *ctree,
- GtkCTreeNode *node,
- GdkColor *color);
-void gtk_ctree_set_row_data (GtkCTree *ctree,
- GtkCTreeNode *node,
- gpointer data);
-void gtk_ctree_set_row_data_full (GtkCTree *ctree,
- GtkCTreeNode *node,
- gpointer data,
- GtkDestroyNotify destroy);
-gpointer gtk_ctree_get_row_data (GtkCTree *ctree,
- GtkCTreeNode *node);
-void gtk_ctree_moveto (GtkCTree *ctree,
- GtkCTreeNode *node,
- gint column,
- gfloat row_align,
- gfloat col_align);
+void gtk_ctree_node_set_text (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ gchar *text);
+void gtk_ctree_node_set_pixmap (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ GdkPixmap *pixmap,
+ GdkBitmap *mask);
+void gtk_ctree_node_set_pixtext (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ gchar *text,
+ guint8 spacing,
+ GdkPixmap *pixmap,
+ GdkBitmap *mask);
+void gtk_ctree_set_node_info (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gchar *text,
+ guint8 spacing,
+ GdkPixmap *pixmap_closed,
+ GdkBitmap *mask_closed,
+ GdkPixmap *pixmap_opened,
+ GdkBitmap *mask_opened,
+ gboolean is_leaf,
+ gboolean expanded);
+void gtk_ctree_node_set_shift (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ gint vertical,
+ gint horizontal);
+GtkCellType gtk_ctree_node_get_cell_type (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column);
+gint gtk_ctree_node_get_text (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ gchar **text);
+gint gtk_ctree_node_get_pixmap (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ GdkPixmap **pixmap,
+ GdkBitmap **mask);
+gint gtk_ctree_node_get_pixtext (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ gchar **text,
+ guint8 *spacing,
+ GdkPixmap **pixmap,
+ GdkBitmap **mask);
+gint gtk_ctree_get_node_info (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gchar **text,
+ guint8 *spacing,
+ GdkPixmap **pixmap_closed,
+ GdkBitmap **mask_closed,
+ GdkPixmap **pixmap_opened,
+ GdkBitmap **mask_opened,
+ gboolean *is_leaf,
+ gboolean *expanded);
+void gtk_ctree_node_set_foreground (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ GdkColor *color);
+void gtk_ctree_node_set_background (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ GdkColor *color);
+void gtk_ctree_node_set_row_data (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gpointer data);
+void gtk_ctree_node_set_row_data_full (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gpointer data,
+ GtkDestroyNotify destroy);
+gpointer gtk_ctree_node_get_row_data (GtkCTree *ctree,
+ GtkCTreeNode *node);
+void gtk_ctree_node_moveto (GtkCTree *ctree,
+ GtkCTreeNode *node,
+ gint column,
+ gfloat row_align,
+ gfloat col_align);
+GtkVisibility gtk_ctree_node_is_visible (GtkCTree *ctree,
+ GtkCTreeNode *node);
/***********************************************************
* GtkCTree specific functions *
***********************************************************/
-void gtk_ctree_set_indent (GtkCTree *ctree,
- gint indent);
-void gtk_ctree_set_reorderable (GtkCTree *ctree,
- gboolean reorderable);
-void gtk_ctree_set_use_drag_icons (GtkCTree *ctree,
- gboolean use_icons);
-void gtk_ctree_set_line_style (GtkCTree *ctree,
- GtkCTreeLineStyle line_style);
-void gtk_ctree_set_drag_compare_func (GtkCTree *ctree,
- GtkCTreeCompareDragFunc cmp_func);
+void gtk_ctree_set_indent (GtkCTree *ctree,
+ gint indent);
+void gtk_ctree_show_stub (GtkCTree *ctree,
+ gboolean show_stub);
+void gtk_ctree_set_reorderable (GtkCTree *ctree,
+ gboolean reorderable);
+void gtk_ctree_set_use_drag_icons (GtkCTree *ctree,
+ gboolean use_icons);
+void gtk_ctree_set_line_style (GtkCTree *ctree,
+ GtkCTreeLineStyle line_style);
+void gtk_ctree_set_drag_compare_func (GtkCTree *ctree,
+ GtkCTreeCompareDragFunc cmp_func);
/***********************************************************
* Tree sorting functions *
***********************************************************/
-void gtk_ctree_sort (GtkCTree *ctree,
- GtkCTreeNode *node);
-void gtk_ctree_sort_recursive (GtkCTree *ctree,
- GtkCTreeNode *node);
+void gtk_ctree_sort_node (GtkCTree *ctree,
+ GtkCTreeNode *node);
+void gtk_ctree_sort_recursive (GtkCTree *ctree,
+ GtkCTreeNode *node);
#ifdef __cplusplus
}
#endif /* __cplusplus */
!GTK_WIDGET_HAS_FOCUS (container->focus_child))
{
if (*GTK_CONTAINER_CLASS (parent_class)->focus)
- return_val = (*GTK_CONTAINER_CLASS (parent_class)->focus)
+ return_val = GTK_CONTAINER_CLASS (parent_class)->focus
(container, direction);
}
}
}
- gtk_ctree_remove (ctree, work);
+ gtk_ctree_remove_node (ctree, work);
selection = GTK_CLIST (ctree)->selection;
}
gtk_ctree_sort_recursive (ctree, NULL);
}
+struct _ExportStruct {
+ gchar *tree;
+ gchar *info;
+ gboolean is_leaf;
+};
+
+typedef struct _ExportStruct ExportStruct;
+
+gboolean
+gnode2ctree (GtkCTree *ctree,
+ guint depth,
+ GNode *gnode,
+ GtkCTreeNode *cnode,
+ gpointer data)
+{
+ ExportStruct *es;
+ GdkPixmap *pixmap_closed;
+ GdkBitmap *mask_closed;
+ GdkPixmap *pixmap_opened;
+ GdkBitmap *mask_opened;
+
+ if (!cnode || !gnode || (!(es = gnode->data)))
+ return FALSE;
+
+ if (es->is_leaf)
+ {
+ pixmap_closed = pixmap3;
+ mask_closed = mask3;
+ pixmap_opened = NULL;
+ mask_opened = NULL;
+ }
+ else
+ {
+ pixmap_closed = pixmap1;
+ mask_closed = mask1;
+ pixmap_opened = pixmap2;
+ mask_opened = mask2;
+ }
+
+ gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
+ mask_closed, pixmap_opened, mask_opened,
+ es->is_leaf, (depth < 3));
+ gtk_ctree_node_set_text (ctree, cnode, 1, es->info);
+ g_free (es);
+ gnode->data = NULL;
+
+ return TRUE;
+}
+
+gboolean
+ctree2gnode (GtkCTree *ctree,
+ guint depth,
+ GNode *gnode,
+ GtkCTreeNode *cnode,
+ gpointer data)
+{
+ ExportStruct *es;
+
+ if (!cnode || !gnode)
+ return FALSE;
+
+ es = g_new (ExportStruct, 1);
+ gnode->data = es;
+ es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf;
+ es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text;
+ es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text;
+ return TRUE;
+}
+
+void export_ctree (GtkWidget *widget, GtkCTree *ctree)
+{
+ char *title[] = { "Tree" , "Info" };
+ static GtkWidget *export_window = NULL;
+ static GtkCTree *export_ctree;
+ GtkWidget *vbox;
+ GtkWidget *button;
+ GtkWidget *sep;
+ GNode *gnode;
+ GtkCTreeNode *node;
+
+ if (!export_window)
+ {
+ export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ &export_window);
+
+ gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
+ gtk_container_border_width (GTK_CONTAINER (export_window), 5);
+
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (export_window), vbox);
+
+ button = gtk_button_new_with_label ("Close");
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
+
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) gtk_widget_destroy,
+ GTK_OBJECT(export_window));
+
+ sep = gtk_hseparator_new ();
+ gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
+
+ export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
+ gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED);
+
+ gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (export_ctree),
+ TRUE, TRUE, 0);
+ gtk_clist_set_selection_mode (GTK_CLIST (export_ctree),
+ GTK_SELECTION_EXTENDED);
+ gtk_clist_set_policy (GTK_CLIST (export_ctree), GTK_POLICY_ALWAYS,
+ GTK_POLICY_AUTOMATIC);
+ gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
+ gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
+ gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
+ }
+
+ if (!GTK_WIDGET_VISIBLE (export_window))
+ gtk_widget_show_all (export_window);
+
+ gtk_clist_clear (GTK_CLIST (export_ctree));
+
+ node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,
+ GTK_CLIST (ctree)->focus_row));
+ if (!node)
+ return;
+
+ gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node,
+ ctree2gnode, NULL);
+ if (gnode)
+ {
+ gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode,
+ gnode2ctree, NULL);
+ g_node_destroy (gnode);
+ }
+}
+
void change_indent (GtkWidget *widget, GtkCTree *ctree)
{
gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
if (GTK_CTREE_ROW (node)->is_leaf)
{
if (GTK_CTREE_ROW (node)->parent)
- gtk_ctree_set_background
+ gtk_ctree_node_set_background
(ctree, node,
GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data);
}
else
- gtk_ctree_set_background (ctree, node, GTK_CTREE_ROW (node)->row.data);
+ gtk_ctree_node_set_background (ctree, node,
+ GTK_CTREE_ROW (node)->row.data);
}
else
- gtk_ctree_set_background (ctree, node, NULL);
+ gtk_ctree_node_set_background (ctree, node, NULL);
}
void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
pages++;
sprintf (buf1, "Page %02d", (gint) rand() % 100);
sprintf (buf2, "Item %d-%d", cur_depth, i);
- sibling = gtk_ctree_insert (ctree, parent, sibling, text, 5, pixmap3,
- mask3, NULL, NULL, TRUE, FALSE);
+ sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
+ pixmap3, mask3, NULL, NULL,
+ TRUE, FALSE);
if (ctree->line_style == GTK_CTREE_LINES_TABBED)
- gtk_ctree_set_background (ctree, sibling, col_bg);
+ gtk_ctree_node_set_background (ctree, sibling, col_bg);
}
if (cur_depth == depth)
books++;
sprintf (buf1, "Book %02d", (gint) rand() % 100);
sprintf (buf2, "Item %d-%d", cur_depth, i);
- sibling = gtk_ctree_insert (ctree, parent, sibling, text, 5, pixmap1,
- mask1, pixmap2, mask2, FALSE, FALSE);
+ sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
+ pixmap1, mask1, pixmap2, mask2,
+ FALSE, FALSE);
col_bg = g_new (GdkColor, 1);
}
gdk_color_alloc (gtk_widget_get_colormap (GTK_WIDGET (ctree)), col_bg);
- gtk_ctree_set_row_data_full (ctree, sibling, col_bg, g_free);
+ gtk_ctree_node_set_row_data_full (ctree, sibling, col_bg, g_free);
if (ctree->line_style == GTK_CTREE_LINES_TABBED)
- gtk_ctree_set_background (ctree, sibling, col_bg);
+ gtk_ctree_node_set_background (ctree, sibling, col_bg);
build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
sibling);
books = 1;
pages = 0;
- parent = gtk_ctree_insert (ctree, NULL, NULL, text, 5, pixmap1,
- mask1, pixmap2, mask2, FALSE, TRUE);
+ parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
+ mask1, pixmap2, mask2, FALSE, TRUE);
col_bg = g_new (GdkColor, 1);
col_bg->red = 0;
col_bg->green = 45000;
col_bg->blue = 55000;
gdk_color_alloc (gtk_widget_get_colormap (GTK_WIDGET (ctree)), col_bg);
- gtk_ctree_set_row_data_full (ctree, parent, col_bg, g_free);
+ gtk_ctree_node_set_row_data_full (ctree, parent, col_bg, g_free);
if (ctree->line_style == GTK_CTREE_LINES_TABBED)
- gtk_ctree_set_background (ctree, parent, col_bg);
+ gtk_ctree_node_set_background (ctree, parent, col_bg);
build_recursive (ctree, 1, d, b, p, parent);
gtk_clist_thaw (GTK_CLIST (ctree));
GTK_SIGNAL_FUNC (sort_all), ctree);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ button = gtk_button_new_with_label ("Export tree");
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (export_ctree), ctree);
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+
hbox = gtk_hbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
}
}
- gtk_ctree_remove (ctree, work);
+ gtk_ctree_remove_node (ctree, work);
selection = GTK_CLIST (ctree)->selection;
}
gtk_ctree_sort_recursive (ctree, NULL);
}
+struct _ExportStruct {
+ gchar *tree;
+ gchar *info;
+ gboolean is_leaf;
+};
+
+typedef struct _ExportStruct ExportStruct;
+
+gboolean
+gnode2ctree (GtkCTree *ctree,
+ guint depth,
+ GNode *gnode,
+ GtkCTreeNode *cnode,
+ gpointer data)
+{
+ ExportStruct *es;
+ GdkPixmap *pixmap_closed;
+ GdkBitmap *mask_closed;
+ GdkPixmap *pixmap_opened;
+ GdkBitmap *mask_opened;
+
+ if (!cnode || !gnode || (!(es = gnode->data)))
+ return FALSE;
+
+ if (es->is_leaf)
+ {
+ pixmap_closed = pixmap3;
+ mask_closed = mask3;
+ pixmap_opened = NULL;
+ mask_opened = NULL;
+ }
+ else
+ {
+ pixmap_closed = pixmap1;
+ mask_closed = mask1;
+ pixmap_opened = pixmap2;
+ mask_opened = mask2;
+ }
+
+ gtk_ctree_set_node_info (ctree, cnode, es->tree, 2, pixmap_closed,
+ mask_closed, pixmap_opened, mask_opened,
+ es->is_leaf, (depth < 3));
+ gtk_ctree_node_set_text (ctree, cnode, 1, es->info);
+ g_free (es);
+ gnode->data = NULL;
+
+ return TRUE;
+}
+
+gboolean
+ctree2gnode (GtkCTree *ctree,
+ guint depth,
+ GNode *gnode,
+ GtkCTreeNode *cnode,
+ gpointer data)
+{
+ ExportStruct *es;
+
+ if (!cnode || !gnode)
+ return FALSE;
+
+ es = g_new (ExportStruct, 1);
+ gnode->data = es;
+ es->is_leaf = GTK_CTREE_ROW (cnode)->is_leaf;
+ es->tree = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[0])->text;
+ es->info = GTK_CELL_PIXTEXT (GTK_CTREE_ROW (cnode)->row.cell[1])->text;
+ return TRUE;
+}
+
+void export_ctree (GtkWidget *widget, GtkCTree *ctree)
+{
+ char *title[] = { "Tree" , "Info" };
+ static GtkWidget *export_window = NULL;
+ static GtkCTree *export_ctree;
+ GtkWidget *vbox;
+ GtkWidget *button;
+ GtkWidget *sep;
+ GNode *gnode;
+ GtkCTreeNode *node;
+
+ if (!export_window)
+ {
+ export_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_signal_connect (GTK_OBJECT (export_window), "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ &export_window);
+
+ gtk_window_set_title (GTK_WINDOW (export_window), "exported ctree");
+ gtk_container_border_width (GTK_CONTAINER (export_window), 5);
+
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_container_add (GTK_CONTAINER (export_window), vbox);
+
+ button = gtk_button_new_with_label ("Close");
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, TRUE, 0);
+
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ (GtkSignalFunc) gtk_widget_destroy,
+ GTK_OBJECT(export_window));
+
+ sep = gtk_hseparator_new ();
+ gtk_box_pack_end (GTK_BOX (vbox), sep, FALSE, TRUE, 10);
+
+ export_ctree = GTK_CTREE (gtk_ctree_new_with_titles (2, 0, title));
+ gtk_ctree_set_line_style (export_ctree, GTK_CTREE_LINES_DOTTED);
+
+ gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (export_ctree),
+ TRUE, TRUE, 0);
+ gtk_clist_set_selection_mode (GTK_CLIST (export_ctree),
+ GTK_SELECTION_EXTENDED);
+ gtk_clist_set_policy (GTK_CLIST (export_ctree), GTK_POLICY_ALWAYS,
+ GTK_POLICY_AUTOMATIC);
+ gtk_clist_set_column_width (GTK_CLIST (export_ctree), 0, 200);
+ gtk_clist_set_column_width (GTK_CLIST (export_ctree), 1, 200);
+ gtk_widget_set_usize (GTK_WIDGET (export_ctree), 300, 200);
+ }
+
+ if (!GTK_WIDGET_VISIBLE (export_window))
+ gtk_widget_show_all (export_window);
+
+ gtk_clist_clear (GTK_CLIST (export_ctree));
+
+ node = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (ctree)->row_list,
+ GTK_CLIST (ctree)->focus_row));
+ if (!node)
+ return;
+
+ gnode = gtk_ctree_export_to_gnode (ctree, NULL, NULL, node,
+ ctree2gnode, NULL);
+ if (gnode)
+ {
+ gtk_ctree_insert_gnode (export_ctree, NULL, NULL, gnode,
+ gnode2ctree, NULL);
+ g_node_destroy (gnode);
+ }
+}
+
void change_indent (GtkWidget *widget, GtkCTree *ctree)
{
gtk_ctree_set_indent (ctree, GTK_ADJUSTMENT (widget)->value);
if (GTK_CTREE_ROW (node)->is_leaf)
{
if (GTK_CTREE_ROW (node)->parent)
- gtk_ctree_set_background
+ gtk_ctree_node_set_background
(ctree, node,
GTK_CTREE_ROW (GTK_CTREE_ROW (node)->parent)->row.data);
}
else
- gtk_ctree_set_background (ctree, node, GTK_CTREE_ROW (node)->row.data);
+ gtk_ctree_node_set_background (ctree, node,
+ GTK_CTREE_ROW (node)->row.data);
}
else
- gtk_ctree_set_background (ctree, node, NULL);
+ gtk_ctree_node_set_background (ctree, node, NULL);
}
void ctree_toggle_line_style (GtkWidget *widget, GtkCTree *ctree)
pages++;
sprintf (buf1, "Page %02d", (gint) rand() % 100);
sprintf (buf2, "Item %d-%d", cur_depth, i);
- sibling = gtk_ctree_insert (ctree, parent, sibling, text, 5, pixmap3,
- mask3, NULL, NULL, TRUE, FALSE);
+ sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
+ pixmap3, mask3, NULL, NULL,
+ TRUE, FALSE);
if (ctree->line_style == GTK_CTREE_LINES_TABBED)
- gtk_ctree_set_background (ctree, sibling, col_bg);
+ gtk_ctree_node_set_background (ctree, sibling, col_bg);
}
if (cur_depth == depth)
books++;
sprintf (buf1, "Book %02d", (gint) rand() % 100);
sprintf (buf2, "Item %d-%d", cur_depth, i);
- sibling = gtk_ctree_insert (ctree, parent, sibling, text, 5, pixmap1,
- mask1, pixmap2, mask2, FALSE, FALSE);
+ sibling = gtk_ctree_insert_node (ctree, parent, sibling, text, 5,
+ pixmap1, mask1, pixmap2, mask2,
+ FALSE, FALSE);
col_bg = g_new (GdkColor, 1);
}
gdk_color_alloc (gtk_widget_get_colormap (GTK_WIDGET (ctree)), col_bg);
- gtk_ctree_set_row_data_full (ctree, sibling, col_bg, g_free);
+ gtk_ctree_node_set_row_data_full (ctree, sibling, col_bg, g_free);
if (ctree->line_style == GTK_CTREE_LINES_TABBED)
- gtk_ctree_set_background (ctree, sibling, col_bg);
+ gtk_ctree_node_set_background (ctree, sibling, col_bg);
build_recursive (ctree, cur_depth + 1, depth, num_books, num_pages,
sibling);
books = 1;
pages = 0;
- parent = gtk_ctree_insert (ctree, NULL, NULL, text, 5, pixmap1,
- mask1, pixmap2, mask2, FALSE, TRUE);
+ parent = gtk_ctree_insert_node (ctree, NULL, NULL, text, 5, pixmap1,
+ mask1, pixmap2, mask2, FALSE, TRUE);
col_bg = g_new (GdkColor, 1);
col_bg->red = 0;
col_bg->green = 45000;
col_bg->blue = 55000;
gdk_color_alloc (gtk_widget_get_colormap (GTK_WIDGET (ctree)), col_bg);
- gtk_ctree_set_row_data_full (ctree, parent, col_bg, g_free);
+ gtk_ctree_node_set_row_data_full (ctree, parent, col_bg, g_free);
if (ctree->line_style == GTK_CTREE_LINES_TABBED)
- gtk_ctree_set_background (ctree, parent, col_bg);
+ gtk_ctree_node_set_background (ctree, parent, col_bg);
build_recursive (ctree, 1, d, b, p, parent);
gtk_clist_thaw (GTK_CLIST (ctree));
GTK_SIGNAL_FUNC (sort_all), ctree);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ button = gtk_button_new_with_label ("Export tree");
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (export_ctree), ctree);
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+
hbox = gtk_hbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
projects / gtk4.git / commitdiff